personal-bot 0.2.8 → 0.2.10

package/src/extension/command.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { packageVersion } from "../common/version.js";
-import { prepareWorkspace } from "../services/workspace/workspace-preparation.js";
+import { initializeWorkspace } from "../services/workspace/workspace-preparation.js";
 import type { Confirmations } from "../ui/confirmation.js";
 import { readPage } from "../ui/pi/reader.js";
 import { choose } from "../ui/pi/menu.js";
@@ -10,6 +10,7 @@ import type { Lifecycle } from "./lifecycle.js";
 import { showAgents } from "./agents-command.js";
 import { showTeams } from "./teams-command.js";
 import { showHistory } from "./history.js";
+import { workspaceDisabledMessage } from "../services/workspace/workspace-config.js";
 
 export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   pi.registerCommand("pbot", {
@@ -22,17 +23,30 @@ export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirma
     handler: async (args, ctx) => {
       const [, command, argument = ""] = args.trim().match(/^(\S+)(?:\s+([\s\S]*))?$/) ?? [];
       confirmations.resume();
+      if (command === "init" && !argument) {
+        await ctx.waitForIdle();
+        const start = !lifecycle.active;
+        await initializeWorkspace(lifecycle.root ?? ctx.cwd);
+        ctx.ui.notify(start ? "工作区已初始化并启用，正在加载 Personal Bot。" : "资料目录已准备；新建的 AGENTS.md 经 /reload 加载。", "info");
+        if (start) await ctx.reload();
+        return;
+      }
+      if (!lifecycle.active) {
+        const configuration = lifecycle.configuration;
+        const status = { workspaceRoot: lifecycle.root ?? ctx.cwd, release: packageVersion, enabled: false,
+          state: configuration?.error || configuration?.enabled ? "error" : "disabled",
+          nextStep: configuration?.error ?? "/pbot init", configuration };
+        ctx.ui.notify(command === "status" ? JSON.stringify(status, null, 2)
+          : configuration ? workspaceDisabledMessage(configuration) : "pbot 工作区实例不可用。", configuration?.error ? "error" : "info");
+        return;
+      }
       async function execute(command: string | undefined, argument: string) {
         const instance = lifecycle.get();
-        if (command === "init" && !argument) {
-          await ctx.waitForIdle(); instance.check(); await prepareWorkspace(instance.root);
-          ctx.ui.notify("资料目录已准备。新建的 AGENTS.md 在 /reload 或下次启动后由 Pi 加载。", "info"); return;
-        }
         if (command === "status" && !argument) {
           const python = instance.pythonEnvironment.status;
-          if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify({ workspaceRoot: instance.root, release: packageVersion, python }, null, 2), "info"); return; }
+          if (ctx.mode !== "tui") { ctx.ui.notify(JSON.stringify({ workspaceRoot: instance.root, release: packageVersion, enabled: true, state: "running", configuration: lifecycle.configuration, python }, null, 2), "info"); return; }
           const agents = instance.agents.list(agentOwner(ctx)), history = instance.history.status;
-          await readPage(ctx, "工作区", [instance.root, "", `版本    ${packageVersion}`,
+          await readPage(ctx, "工作区", [instance.root, "", "状态    已启动", `配置    ${lifecycle.configuration?.path ?? ""}`, `版本    ${packageVersion}`,
             `模型    ${ctx.model && !(ctx.model.provider === "unknown" && ctx.model.id === "unknown") ? ctx.model.provider + "/" + ctx.model.id : "未选择"}`,
             `专家    ${agents.length} 位 · ${agents.filter(value => value.alive).length} 位存活`,
             `Python  ${stateLabel(python.state)}`, ...(python.directory ? [python.directory] : []), ...(python.error ? ["", python.error] : []),
@@ -58,7 +72,10 @@ export function registerCommand(pi: ExtensionAPI, lifecycle: Lifecycle, confirma
         const choice = await choose(ctx, `Personal Bot · Python ${stateLabel(instance.pythonEnvironment.status.state)}`, choices);
         if (!choice) return;
         const command = ["agents", "teams", "history", "status", "init", "python"][choices.indexOf(choice)]!;
-        try { await execute(command, command === "python" ? "setup" : ""); }
+        try {
+          if (command === "init") { await ctx.waitForIdle(); instance.check(); await initializeWorkspace(instance.root); ctx.ui.notify("资料目录已准备。", "info"); }
+          else await execute(command, command === "python" ? "setup" : "");
+        }
         catch (error) { ctx.ui.notify(error instanceof Error ? error.message : String(error), "error"); }
       }
     },

package/src/extension/dsh/command.ts

@@ -3,12 +3,11 @@ import type {} from "@deepseek-ai/dsh-commands";
 import { Type, type Static } from "typebox";
 import { object, json } from "../../common/json.js";
 import { requireThat, schema } from "../../common/validation.js";
-import { prepareWorkspace } from "../../services/workspace/workspace-preparation.js";
 import { executeAgent, type AgentInput } from "../../tools/agents/actions.js";
 import { dshAgentActionSchema } from "../../tools/agents/dsh-contract.js";
 import { executeTeam, executeTeamMessage } from "../../tools/teams/actions.js";
 import { teamActionSchema, teamParametersSchema, teamMessageActionSchema, teamMessageParametersSchema } from "../../tools/teams/contract.js";
-import { dshStatus, type PbotManagement } from "./management.js";
+import { dshWorkspaceStatus, type PbotManagement } from "./management.js";
 import type { DshWorkspaces } from "./workspace.js";
 
 const validAgent = schema(dshAgentActionSchema), validTeam = schema(teamActionSchema), validMessage = schema(teamMessageActionSchema);
@@ -23,20 +22,26 @@ export function registerDshCommand(ctx: Context, workspaces: DshWorkspaces, mana
     input: { hint: "status | init | python setup | agent/chat/team/post/history/records JSON", attachments: true },
     async handler({ agent, rawInput, signal, attachments, commandId }) {
       signal.throwIfAborted();
+      const command = rawInput.trim(), split = command.search(/\s/);
+      if (!command || command === "status") {
+        requireThat(!attachments.length, "状态查询不接受附件。");
+        const status = await dshWorkspaceStatus(workspaces, agent);
+        signal.throwIfAborted(); return { kind: "success", text: JSON.stringify(status, null, 2) };
+      }
+      if (command === "init") {
+        requireThat(!attachments.length, "初始化不接受附件。");
+        await workspaces.initialize(agent);
+        signal.throwIfAborted();
+        return { kind: "success", text: JSON.stringify(await dshWorkspaceStatus(workspaces, agent), null, 2) };
+      }
       const workspace = await workspaces.get(agent);
       signal.throwIfAborted();
-      const command = rawInput.trim(), split = command.search(/\s/);
       const verb = split < 0 ? command : command.slice(0, split);
       requireThat(verb === "chat" || !attachments.length, "输入框附件仅用于 chat 人工对话。");
-      if (command === "init") {
-        await prepareWorkspace(workspace.root); workspace.check();
-        return { kind: "success", text: "资料目录已准备；已有文件保留。" };
-      }
       if (command === "python setup") {
         const result = await workspaces.preparePython(); workspace.check();
         return { kind: "success", text: JSON.stringify(result, null, 2) };
       }
-      if (!command || command === "status") return { kind: "success", text: JSON.stringify(dshStatus(workspaces, workspace), null, 2) };
       requireThat(split >= 0, usage);
       const input: unknown = JSON.parse(command.slice(split));
       requireThat(object(input), "命令参数必须是 JSON 对象。");

package/src/extension/dsh/history.ts

@@ -18,9 +18,9 @@ export class DshHistoryWork {
   #closing: Promise<void> | undefined;
   constructor(private readonly ctx: Context, root: string) {
     const agents = new AgentFiles(dshHomePath("pbot", "subagents"), "dsh");
-    this.service = new HistoryService(root, new HistoryFiles(join(root, ".dsh/pbot/history"), "dsh"),
+    this.service = new HistoryService(root, new HistoryFiles(join(root, ".pbot/history"), "dsh"),
       new DshHistory(ctx, root, () => agents.list().filter(value => value.workspace === root).map(value => value.agentId)),
-      undefined, new HistoryFiles(join(root, ".pi/pbot/history")));
+      new HistoryFiles(join(root, ".pbot/history")));
   }
   attach(agent: Agent) { this.#parents.add(agent); return () => { this.#parents.delete(agent); }; }
   cancel() { this.#controller?.abort(); }

package/src/extension/dsh/management.ts

@@ -1,3 +1,4 @@
+import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { Context } from "@deepseek-ai/cordis";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import type {} from "@deepseek-ai/dsh-typert-registry";
@@ -25,31 +26,46 @@ const validRequest = schema(requestSchema), validExpert = schema(expertSchema),
 export function dshStatus(workspaces: DshWorkspaces, workspace: DshWorkspace): Json {
   workspace.check();
   const agents = workspace.agents.list(workspace.owner);
-  return json({ host: "dsh", release: packageVersion, workspaceRoot: workspace.root, sessionId: workspace.agent.id,
+  return json({ host: "dsh", release: packageVersion, enabled: true, state: "running", workspaceRoot: workspace.root, sessionId: workspace.agent.id,
     model: workspace.agent.model.current() ?? null, python: workspaces.python.status,
     controlError: workspace.controlError ?? null, history: workspace.history.status,
     agents, teams: workspace.teams.list(workspace.owner, agents) });
 }
 
+/** Status remains available when this workspace has not opted in. */
+export async function dshWorkspaceStatus(workspaces: DshWorkspaces, agent: Agent): Promise<Json> {
+  const { root, configuration } = await workspaces.configuration(agent);
+  if (!configuration.enabled) return json({ host: "dsh", release: packageVersion, enabled: false,
+    state: configuration.error ? "error" : "disabled", nextStep: configuration.error ? configuration.error : "/pbot init",
+    workspaceRoot: root, sessionId: agent.id, configuration, model: agent.model.current() ?? null, agents: [], teams: [] });
+  return json({ ...dshStatus(workspaces, await workspaces.get(agent)) as Record<string, Json>, configuration });
+}
+
 /** Native Remote owns transport and access checks. These workspace reads do not admit or cancel execution. */
 export class PbotManagement extends TypertRemoteService {
   constructor(ctx: Context, private readonly workspaces: DshWorkspaces) { super(ctx, "pbotManagement", { namespace: "pbot" }); }
 
-  private async workspace(request: Json, signal: AbortSignal) {
+  private parent(request: Json, signal: AbortSignal) {
     signal.throwIfAborted(); requireThat(validRequest(request), "管理查询参数无效。");
     const args = request as Static<typeof requestSchema>;
     const agent = this.ctx.agents.get(SessionId(args.parentSessionId));
     requireThat(agent, "父会话未加载或已关闭，请在原生会话页面重新打开。");
+    return { agent, input: args.input };
+  }
+
+  private async workspace(request: Json, signal: AbortSignal) {
+    const { agent, input } = this.parent(request, signal);
     const workspace = await this.workspaces.get(agent);
     signal.throwIfAborted(); workspace.check();
-    return { workspace, input: args.input, signal: AbortSignal.any([signal, workspace.lifetime.signal]) };
+    return { workspace, input, signal: AbortSignal.any([signal, workspace.lifetime.signal]) };
   }
 
   @Remote
   async snapshot(request: Json, signal: AbortSignal): Promise<Json> {
-    const { workspace, input } = await this.workspace(request, signal);
+    const { agent, input } = this.parent(request, signal);
     requireThat(input === undefined, "工作区状态查询不接受额外参数。");
-    return dshStatus(this.workspaces, workspace);
+    const status = await dshWorkspaceStatus(this.workspaces, agent);
+    signal.throwIfAborted(); return status;
   }
 
   @Remote

package/src/extension/dsh/workspace.ts

@@ -18,6 +18,10 @@ import { registerDshHistoryTool } from "../../tools/history/dsh-tool.js";
 import { activatePython } from "../../integrations/python-activation.js";
 import { PythonEnvironmentService } from "../../services/workspace/python-environment-service.js";
 import { requireThat } from "../../common/validation.js";
+import { registerDshSkills } from "../../integrations/dsh/skills.js";
+import { readWorkspaceConfig, workspaceDisabledMessage } from "../../services/workspace/workspace-config.js";
+import type { WorkspaceConfiguration } from "../../model/workspace-config.js";
+import { initializeWorkspace } from "../../services/workspace/workspace-preparation.js";
 
 export const dshDependencies = ["agents", "sessions", "sessionPersistence", "sessionQuery", "llm", "tools", "systemPrompt", "skills", "fs", "attachments", "workingDirectory", "approval"];
 
@@ -45,6 +49,7 @@ export class DshWorkspace {
             { check: this.check, release: () => this.host.release(d.agentId, generation) });
           this.#experts.set(d.agentId, runtime);
           scope.effect(() => () => { if (this.#experts.get(d.agentId) === runtime) this.#experts.delete(d.agentId); });
+          registerDshSkills(scope, child);
           await dshResources(scope, child, root, "general-purpose", () => python.status, runtime.check);
           const teamTool = dshExpertTools(scope, child, d.options);
           if (teamTool) registerDshTeamMessageTool(scope, child, this.teams, runtime.actor, runtime.check);
@@ -67,6 +72,7 @@ export class DshWorkspace {
   async open() {
     this.check();
     this.#scope = await this.agent.ctx.plugin({ name: "pbot-coordinator", inject: dshDependencies, apply: async ctx => {
+      registerDshSkills(ctx, this.agent);
       await dshResources(ctx, this.agent, this.root, "coordinator", () => this.python.status, this.check);
       registerDshFileEvents(ctx, this.agent, this.root, false, this.check);
       registerDshAgentTool(ctx, this.agent, this.agents, this.owner, this.check);
@@ -108,7 +114,9 @@ export class DshWorkspace {
 /** The execution component owns Python; closing one Session must not undo its activation. */
 export class DshWorkspaces {
   readonly python = new PythonEnvironmentService(process.cwd());
-  readonly #parents = new Map<Agent, Promise<DshWorkspace>>();
+  readonly #parents = new Map<Agent, Promise<DshWorkspace | undefined>>();
+  readonly #initializing = new Map<string, Promise<void>>();
+  readonly #configurations = new Map<Agent, { root: string; configuration: WorkspaceConfiguration }>();
   readonly #parentEffects = new Map<Agent, () => Promise<void>>();
   readonly #histories = new Map<string, { work: DshHistoryWork; users: number }>();
   readonly #lifetime = new AbortController();
@@ -144,16 +152,29 @@ export class DshWorkspaces {
     const opening = (async () => {
       const root = await realpath(agent.session.header.cwd ?? process.cwd());
       this.#lifetime.signal.throwIfAborted();
+      const configuration = await readWorkspaceConfig(root);
+      this.#lifetime.signal.throwIfAborted();
+      this.#configurations.set(agent, { root, configuration });
+      if (!configuration.enabled) {
+        if (configuration.error) this.ctx.logger.warn(configuration.error);
+        const dispose = agent.ctx.effect(() => () => {
+          this.#parents.delete(agent); this.#configurations.delete(agent); this.#parentEffects.delete(agent);
+        });
+        this.#parentEffects.set(agent, dispose);
+        return undefined;
+      }
       const history = await this.history(root);
       let workspace: DshWorkspace | undefined;
       try {
         workspace = new DshWorkspace(this.ctx, root, agent, this.python, this.#lifetime.signal, history.work, history.release);
         const owned = workspace;
         const dispose = agent.ctx.effect(() => async () => {
-          this.#parents.delete(agent); this.#parentEffects.delete(agent); await owned.close();
+          this.#parents.delete(agent); this.#configurations.delete(agent); this.#parentEffects.delete(agent); await owned.close();
         });
         this.#parentEffects.set(agent, dispose);
-        await workspace.open(); this.#lifetime.signal.throwIfAborted(); return workspace;
+        await workspace.open(); this.#lifetime.signal.throwIfAborted();
+        void this.preparePython().catch(error => this.ctx.logger.warn(String(error)));
+        return workspace;
       } catch (error) {
         try {
           const dispose = this.#parentEffects.get(agent);
@@ -171,10 +192,45 @@ export class DshWorkspaces {
     this.#lifetime.signal.throwIfAborted();
     requireThat(this.ctx.agents.get(agent.id) === agent, "父会话已关闭。");
     const workspace = await this.open(agent);
+    const configuration = this.#configurations.get(agent)?.configuration;
+    requireThat(workspace, configuration ? workspaceDisabledMessage(configuration) : "pbot 工作区实例不可用。");
     workspace.check();
     return workspace;
   }
 
+  async configuration(agent: Agent) {
+    this.#lifetime.signal.throwIfAborted();
+    requireThat(this.ctx.agents.get(agent.id) === agent, "父会话已关闭。");
+    await this.open(agent);
+    this.#lifetime.signal.throwIfAborted();
+    const current = this.#configurations.get(agent);
+    requireThat(current && this.ctx.agents.get(agent.id) === agent, "父会话已关闭。");
+    return current;
+  }
+
+  async initialize(agent: Agent): Promise<DshWorkspace> {
+    const { root } = await this.configuration(agent);
+    let pending = this.#initializing.get(root);
+    if (!pending) {
+      pending = (async () => {
+        await initializeWorkspace(root);
+        this.#lifetime.signal.throwIfAborted();
+        const configuration = await readWorkspaceConfig(root);
+        for (const [parent, current] of [...this.#configurations]) {
+          if (current.root !== root || this.ctx.agents.get(parent.id) !== parent) continue;
+          const workspace = await this.#parents.get(parent);
+          if (workspace) { this.#configurations.set(parent, { root, configuration }); continue; }
+          await this.#parentEffects.get(parent)?.();
+          await this.open(parent);
+        }
+      })();
+      this.#initializing.set(root, pending);
+    }
+    try { await pending; }
+    finally { if (this.#initializing.get(root) === pending) this.#initializing.delete(root); }
+    return this.get(agent);
+  }
+
   preparePython() {
     this.#lifetime.signal.throwIfAborted();
     if (this.#preparing) return this.#preparing;
@@ -192,14 +248,15 @@ export class DshWorkspaces {
     this.#lifetime.abort();
     this.#closing = (async () => {
       try {
+        await Promise.allSettled(this.#initializing.values());
         const opened = await Promise.allSettled(this.#parents.values());
-        const closed = await Promise.allSettled(opened.filter(v => v.status === "fulfilled").map(v => v.value.close()));
+        const closed = await Promise.allSettled(opened.flatMap(value => value.status === "fulfilled" && value.value ? [value.value.close()] : []));
         const effects = await Promise.allSettled([...this.#parentEffects.values()].map(dispose => dispose()));
         const histories = await Promise.allSettled([...this.#histories.values()].map(value => value.work.close()));
         await this.python.close();
         const errors = [...new Set([...closed, ...effects, ...histories].flatMap(value => value.status === "rejected" ? [value.reason] : []))];
         if (errors.length) throw new AggregateError(errors, "部分 dsh 工作区未能完成关闭。");
-      } finally { this.#parents.clear(); this.#parentEffects.clear(); this.#histories.clear(); this.#restorePython?.(); this.#restorePython = undefined; }
+      } finally { this.#parents.clear(); this.#configurations.clear(); this.#parentEffects.clear(); this.#histories.clear(); this.#restorePython?.(); this.#restorePython = undefined; }
     })();
     return this.#closing;
   }

package/src/extension/events.ts

@@ -7,11 +7,19 @@ import { resourceRoot } from "../common/paths.js";
 import { agentText } from "../integrations/agent-resources.js";
 import type { Confirmations } from "../ui/confirmation.js";
 import type { Lifecycle } from "./lifecycle.js";
+import { readWorkspaceConfig, workspaceDisabledMessage } from "../services/workspace/workspace-config.js";
+import { workspaceSkillPaths } from "../integrations/pi/skills.js";
 
 export function registerEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmations: Confirmations) {
   pi.on("session_start", async (_event, ctx) => {
     try {
       await lifecycle.open(ctx.cwd);
+      if (!lifecycle.active) {
+        ctx.ui.setStatus("pbot", lifecycle.configuration?.error ? "PBot 配置错误" : "PBot 未启用 · /pbot init");
+        if (ctx.hasUI && lifecycle.configuration) ctx.ui.notify(workspaceDisabledMessage(lifecycle.configuration), lifecycle.configuration.error ? "error" : "info");
+        return;
+      }
+      ctx.ui.setStatus("pbot", "PBot 已启动");
       if (ctx.mode === "tui") ctx.ui.setStatus("pbot-python", "Python 准备中");
       else ctx.ui.notify("正在准备共享 Python 环境；首次安装可能需要数分钟。", "info");
       try { await lifecycle.get().preparePython(); }
@@ -21,10 +29,15 @@ export function registerEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmat
         else if (ctx.hasUI) ctx.ui.notify(message, "warning"); else console.error(message);
       } finally { if (ctx.mode === "tui") ctx.ui.setStatus("pbot-python", undefined); }
     } catch (error) {
+      ctx.ui.setStatus("pbot", "PBot 启动失败");
       if (ctx.hasUI) ctx.ui.notify(error instanceof Error ? error.message : "pbot 启动失败。", "error");
       else throw error;
     }
   });
+  pi.on("resources_discover", (_event, ctx) => {
+    if (!lifecycle.active) return;
+    return { skillPaths: workspaceSkillPaths(pi, ctx.cwd) };
+  });
   pi.on("before_agent_start", async (event, ctx) => {
     const instance = lifecycle.active;
     if (!instance) return;
@@ -49,7 +62,11 @@ export function registerEvents(pi: ExtensionAPI, lifecycle: Lifecycle, confirmat
   pi.on("session_before_switch", () => { lifecycle.active?.cancelWork(); });
   pi.on("session_before_fork", () => { lifecycle.active?.cancelWork(); });
   pi.on("session_before_tree", () => { lifecycle.active?.cancelWork(); });
-  pi.on("session_shutdown", event => lifecycle.close(event.reason === "reload"));
+  pi.on("session_shutdown", async (event, ctx) => {
+    const preserve = event.reason === "reload" && lifecycle.root && (await readWorkspaceConfig(lifecycle.root)).enabled;
+    try { await lifecycle.close(Boolean(preserve)); }
+    finally { ctx.ui.setStatus("pbot", undefined); ctx.ui.setStatus("pbot-python", undefined); }
+  });
   pi.on("tool_call", async (event, ctx) => {
     const instance = lifecycle.active;
     if (["write", "edit"].includes(event.toolName) && "path" in event.input && typeof event.input.path === "string") {

package/src/extension/lifecycle.ts

@@ -8,6 +8,8 @@ import type { AgentService } from "../services/agents/agent-service.js";
 import type { TeamService } from "../services/agents/team-service.js";
 import type { CallAccess } from "../tools/access.js";
 import type { HistoryService } from "../services/history/history-service.js";
+import { readWorkspaceConfig, workspaceDisabledMessage } from "../services/workspace/workspace-config.js";
+import type { WorkspaceConfiguration } from "../model/workspace-config.js";
 
 export class WorkspaceInstance implements CallAccess {
   readonly #controller = new AbortController();
@@ -62,16 +64,21 @@ export class WorkspaceInstance implements CallAccess {
 }
 export class Lifecycle {
   #active: WorkspaceInstance | undefined;
+  configuration: WorkspaceConfiguration | undefined;
+  root: string | undefined;
   constructor(private readonly create: (root: string) => WorkspaceInstance,
     private readonly register: (instance: WorkspaceInstance) => void, private readonly hide: () => void) {}
   get active() { return this.#active; }
   get() {
-    requireThat(this.#active, "pbot 工作区实例不可用。");
+    requireThat(this.#active, this.configuration ? workspaceDisabledMessage(this.configuration) : "pbot 工作区实例不可用。");
     this.#active.check(); return this.#active;
   }
   async open(root: string) {
     await this.close();
-    const instance = this.create(await realpath(root));
+    this.root = await realpath(root);
+    this.configuration = await readWorkspaceConfig(this.root);
+    if (!this.configuration.enabled) return;
+    const instance = this.create(this.root);
     this.#active = instance;
     try { this.register(instance); }
     catch (error) { await this.close(); throw error; }

package/src/extension/setup-cli.ts

@@ -92,7 +92,7 @@ export async function main(args: string[]): Promise<number> {
     const failed = result.results.some(item => item.state === "failed");
     if (!result.pi) return 1;
     ui.text("\n软件安装阶段结束。初始化、Python 环境和外部服务的状态由 Pi/pbot/插件分别报告。");
-    if (await ui.confirm(failed ? "部分插件失败，是否仍先启动 Pi" : "立即启动 Pi", !failed)) {
+    if (await ui.confirm(failed ? "部分插件失败，是否仍启动 Pi 并初始化启用工作区" : "启动 Pi 并初始化启用工作区", !failed)) {
       process.stdin.pause();
       await host.start(result.pi, workspace);
     } else {

package/src/extension/subagent-entry.ts

@@ -20,9 +20,10 @@ import { agentFileTools } from "../integrations/pi/agent-tools.js";
 import { resourceRoot } from "../common/paths.js";
 import { requireThat } from "../common/validation.js";
 import { packageVersion, releaseLine } from "../common/version.js";
+import { readWorkspaceConfig, workspaceDisabledMessage } from "../services/workspace/workspace-config.js";
 
 /** Explicit child composition; never installs main commands or approval capabilities. */
-export default function subagent(pi: ExtensionAPI) {
+export default async function subagent(pi: ExtensionAPI) {
   const id = process.env.PBOT_SUBAGENT_RUN_ID, directory = process.env.PBOT_SUBAGENT_DIR, generation = process.env.PBOT_SUBAGENT_GENERATION;
   requireThat(id && directory && generation, "缺少子会话启动身份。");
   const files = new AgentFiles(dirname(realpathSync(directory)));
@@ -30,6 +31,8 @@ export default function subagent(pi: ExtensionAPI) {
   const d = files.read(id, "descriptor.json", descriptor);
   requireThat(d.agentId === id && releaseLine(d.release) === releaseLine(packageVersion), "子会话身份或版本无效。");
   requireThat(files.read(id, "launch.json", launch).generation === generation, "子会话启动代次已失效。");
+  const configuration = await readWorkspaceConfig(d.workspace);
+  requireThat(configuration.enabled, workspaceDisabledMessage(configuration));
   const teams = new TeamService(d.workspace, files, new TeamFiles(files));
   const lifetime = new AbortController();
   let activeTeam: TeamLink | undefined, pendingPause: string | undefined;

package/src/integrations/dsh/skills.ts

@@ -0,0 +1,30 @@
+import { join } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { scopeParentOf } from "@deepseek-ai/dsh-scope";
+import { FileSystemSkillProvider } from "@deepseek-ai/dsh-skill-filesystem";
+import { resourceRoot } from "../../common/paths.js";
+
+/** Keep bundled methods local to this Agent without overriding its native project/user methods. */
+export function registerDshSkills(ctx: Context, agent: Agent): void {
+  let filesystem: FileSystemSkillProvider;
+  ctx.skills.registerProvider(control => {
+    filesystem = new FileSystemSkillProvider(ctx, control, {
+      providerName: "pbot", includeDefaultRoots: false, bundledSkillDir: join(resourceRoot, "skills"),
+    });
+    return {
+      name: "pbot",
+      async list(options) {
+        const inherited = await ctx.skills.snapshot({ ...options, scope: scopeParentOf(agent) });
+        const preferred = new Set(inherited.skills.filter(skill => skill.provider !== "pbot").map(skill => skill.name));
+        const listed = await filesystem.list(options);
+        const candidates = Array.isArray(listed) ? listed : listed.candidates;
+        return { candidates: candidates.filter(skill => !preferred.has(skill.name)),
+          complete: inherited.complete && (Array.isArray(listed) || listed.complete) };
+      },
+      get: (candidate, options) => filesystem.get(candidate, options),
+    };
+  });
+  ctx.effect(() => () => filesystem.dispose());
+  ctx.on("fs/observed", target => { filesystem.observeHostMutation(target.displayPath); });
+}

package/src/integrations/pi/skills.ts

@@ -0,0 +1,52 @@
+import { basename, dirname, join, matchesGlob, normalize, relative, resolve, sep } from "node:path";
+import { getAgentDir, loadSkillsFromDir, parseArgs, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resourceRoot } from "../../common/paths.js";
+
+/** Dynamic resources follow the owning package's native include/exclude settings. */
+export function workspaceSkillPaths(pi: ExtensionAPI, cwd: string): string[] {
+  if (parseArgs(process.argv.slice(2)).noSkills) return [];
+  const root = resolve(resourceRoot, ".."), origin = pi.getCommands().find(command => command.name === "pbot")?.sourceInfo;
+  const files = loadSkillsFromDir({ dir: join(resourceRoot, "skills"), source: "pbot" }).skills.map(skill => skill.filePath);
+  const posix = (path: string) => normalize(path).split(sep).join("/");
+  const matches = (file: string, pattern: string, exact = false) => {
+    const target = posix(pattern), parent = dirname(file);
+    const paths = [relative(root, file), file, relative(root, parent), parent];
+    if (!exact) paths.push(basename(file), basename(parent));
+    return paths.some(path => exact ? posix(path) === target : matchesGlob(posix(path), target));
+  };
+  const own = (entry: string | { source: string }) => {
+    const source = typeof entry === "string" ? entry : entry.source;
+    return source === origin?.source || [join(cwd, ".pi"), getAgentDir(), cwd].some(base => resolve(base, source) === root);
+  };
+  let entries = (pi.getSettings().packages ?? []).filter(own);
+  if (origin?.origin === "package" && (!entries.length || entries.every(entry => typeof entry !== "string" && entry.autoload === false))) {
+    const global = SettingsManager.create(cwd, getAgentDir(), { projectTrusted: false }).getGlobalSettings();
+    entries = [...(global.packages ?? []).filter(own), ...entries];
+  }
+  let selected = new Set(entries.length && entries.every(entry => typeof entry !== "string" && entry.autoload === false) ? [] : files);
+  for (const entry of entries) {
+    if (typeof entry === "string" || entry.skills === undefined) continue;
+    const patterns = entry.skills;
+    if (entry.autoload === false) {
+      for (const pattern of patterns) {
+        const exact = /^[+-]/.test(pattern), target = pattern.replace(/^[!+-]/, "");
+        for (const file of files.filter(file => matches(file, target, exact))) {
+          if (/^[!-]/.test(pattern)) selected.delete(file); else selected.add(file);
+        }
+      }
+      continue;
+    }
+    if (!patterns.length) { selected.clear(); continue; }
+    const includes = patterns.filter(pattern => !/^[!+-]/.test(pattern));
+    selected = new Set(files.filter(file => !includes.length || includes.some(pattern => matches(file, pattern))));
+    for (const prefix of ["!", "+", "-"]) {
+      for (const pattern of patterns.filter(pattern => pattern.startsWith(prefix))) {
+        for (const file of files.filter(file => matches(file, pattern.slice(1), prefix !== "!"))) {
+          if (prefix === "+") selected.add(file); else selected.delete(file);
+        }
+      }
+    }
+  }
+  return [...selected];
+}

package/src/model/history.ts

@@ -19,6 +19,7 @@ export interface HistoryNode extends HistoryExchange {
   ready: boolean;
 }
 export interface HistoryRecord {
+  host: HistoryHost;
   id: string;
   sessionId: string;
   name: string;

package/src/model/workspace-config.ts

@@ -0,0 +1,10 @@
+export interface WorkspaceConfig {
+  enabled?: boolean;
+}
+
+export interface WorkspaceConfiguration {
+  path: string;
+  present: boolean;
+  enabled: boolean;
+  error?: string;
+}

package/src/pbot.ts

@@ -13,7 +13,6 @@ import { HistoryService } from "./services/history/history-service.js";
 import { HistoryFiles } from "./storage/history-files.js";
 import { PiHistory } from "./integrations/pi/history.js";
 import { sessionRef } from "./storage/agent-files.js";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
 import { registerHistoryEvents } from "./extension/history.js";
 
@@ -23,11 +22,11 @@ export default function pbot(pi: ExtensionAPI) {
   const confirmations = new Confirmations(), registry = new ToolRegistry(pi);
   const lifecycle = new Lifecycle(root => {
     const agents = new AgentService(root, agentDirectory(), new PiAgents());
-    const history = new HistoryService(root, new HistoryFiles(join(root, ".pi/pbot/history")), new PiHistory(root, () =>
+    const history = new HistoryService(root, new HistoryFiles(join(root, ".pbot/history")), new PiHistory(root, () =>
       agents.files.list().filter(agent => agent.workspace === root).flatMap(agent => {
         const file = agents.files.optional(agent.agentId, "session-ref.json", sessionRef)?.file;
         return file ? [file] : [];
-      })), new HistoryFiles(join(getAgentDir(), "pbot/history")), new HistoryFiles(join(root, ".dsh/pbot/history"), "dsh"));
+      })), new HistoryFiles(join(root, ".pbot/history"), "dsh"));
     return new WorkspaceInstance(root, new PythonEnvironmentService(root), agents, new TeamService(root, agents.files, agents.teamFiles), history);
   }, instance => registry.register(mainTools(instance.agents, instance.teams, instance.history, instance)), () => registry.hide());
   registerCommand(pi, lifecycle, confirmations);