personal-bot 0.2.9 → 0.2.10

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);

package/src/services/history/history-service.ts

@@ -4,7 +4,7 @@ import type { HistoryFiles } from "../../storage/history-files.js";
 import { requireThat } from "../../common/validation.js";
 
 /** Shared prefixes reuse nodes; only consecutive exchanges on one native branch can merge. */
-export function indexHistory(session: HistorySession, previous?: HistoryRecord, host: HistoryHost = "pi"): HistoryRecord {
+export function indexHistory(session: HistorySession, previous?: HistoryRecord, host: HistoryHost = previous?.host ?? "pi"): HistoryRecord {
   const id = previous?.id ?? (host === "dsh" ? "dsh-" : "") + randomUUID(), nodes = new Map<string, HistoryNode>();
   const old = new Map(previous?.nodes.map(node => [node.id, node])), changed = new Set<string>();
   const add = (value: HistoryExchange, level: number, children: string[] = []): HistoryNode => {
@@ -37,7 +37,7 @@ export function indexHistory(session: HistorySession, previous?: HistoryRecord,
     from: dates[0] ?? "", to: dates.at(-1) ?? "", parents: [],
     children: [...roots].sort((a, b) => nodes.get(a)!.from.localeCompare(nodes.get(b)!.from)) });
   for (const node of nodes.values()) for (const child of node.children) nodes.get(child)!.parents.push(node.id);
-  return { id, sessionId: session.sessionId, name: session.name, nodes: [...nodes.values()] };
+  return { host, id, sessionId: session.sessionId, name: session.name, nodes: [...nodes.values()] };
 }
 
 export interface HistoryQuery { host?: HistoryHost; query?: string; sessionId?: string; from?: string; to?: string; offset?: number; limit?: number }
@@ -69,12 +69,12 @@ export class HistoryService {
   #sourceWarnings: string[] = [];
   #summaryError: string | undefined;
   constructor(readonly root: string, private readonly files: HistoryFiles, private readonly source: HistorySource,
-    private previousFiles?: HistoryFiles, private readonly otherFiles?: HistoryFiles) {
+    private readonly otherFiles?: HistoryFiles) {
     requireThat(source.host === files.host && (!otherFiles || otherFiles.host !== files.host), "历史来源与归档目录不匹配。");
-    requireThat(files.host === "pi" || !previousFiles, "dsh 不导入 Pi 旧归档。");
   }
   check() { requireThat(!this.#closed, "历史服务已关闭。"); }
-  get warnings() { return [...this.#sourceWarnings, ...(this.#summaryError ? [this.files.host + " 摘要：" + this.#summaryError] : [])]; }
+  get warnings() { return [...new Set([...this.#sourceWarnings, ...this.files.warnings, ...(this.otherFiles?.warnings ?? []),
+    ...(this.#summaryError ? [this.files.host + " 摘要：" + this.#summaryError] : [])])]; }
   get status() { return { loaded: this.#loaded, organizing: Boolean(this.#work), pending: this.#loaded ? this.#records.filter(value => value.host === this.files.host)
     .reduce((total, value) => total + value.record.nodes.filter(node => node.kind === "summary" && !node.ready).length, 0) : null, warnings: this.warnings }; }
   refresh(location: HistoryLocation, signal?: AbortSignal): Promise<void> {
@@ -90,35 +90,25 @@ export class HistoryService {
     const warning = (host: HistoryHost, error: unknown) => { this.check(); signal?.throwIfAborted(); warnings.push(host + ": " + String(error)); };
     let known: HistoryRecord[] = [];
     try {
-      const before = this.files.list(); known = before;
-      let imports: HistoryRecord[] = [], importedPrevious = !this.previousFiles;
-      if (this.previousFiles) {
-        try { imports = this.previousFiles.list(this.root); importedPrevious = true; } catch (error) { warning("pi", error); }
-      }
+      try { this.files.migrate(this.root); } finally { known = this.files.list(); }
+      const before = known;
       let sessions: HistorySession[] = [];
       try {
         const scanned = await this.source.scan(location, signal); sessions = scanned.sessions;
         warnings.push(...scanned.warnings.map(value => this.files.host + ": " + value));
       } catch (error) { warning(this.files.host, error); }
       this.check(); signal?.throwIfAborted();
-      if (sessions.length || imports.length || (this.files.host === "pi" && before.some(value => "file" in value))) {
+      if (sessions.length) {
         known = this.files.control(() => {
           this.check(); signal?.throwIfAborted();
-          const latest = this.files.list(), current = new Map(latest.map(record => [record.sessionId, record])), imported = new Set<string>();
-          if (this.files.host === "pi") {
-            for (const value of latest) if ("file" in value) {
-              const { id, sessionId, name, nodes } = value, clean = { id, sessionId, name, nodes };
-              this.files.save(clean); current.set(sessionId, clean);
-            }
-            for (const { id, sessionId, name, nodes } of imports) if (!current.has(sessionId)) {
-              const value = { id, sessionId, name, nodes }; this.files.save(value); current.set(sessionId, value); imported.add(sessionId);
-            }
-          }
+          const latest = this.files.list(), current = new Map(latest.map(record => [record.sessionId, record]));
           for (const session of sessions) {
             const previous = current.get(session.sessionId), captured = before.find(record => record.sessionId === session.sessionId);
+            // An unreadable archive may own this session; avoid assigning it a second root ID.
+            if (!previous && this.files.warnings.length) continue;
             // A concurrent source update must not be overwritten by this older scan. Summary-only updates remain reusable.
             if (captured && rawSource(captured) !== rawSource(previous)) continue;
-            if (!captured && previous && !imported.has(session.sessionId)) continue;
+            if (!captured && previous) continue;
             const value = indexHistory(session, previous, this.files.host);
             if (JSON.stringify(previous) !== JSON.stringify(value)) this.files.save(value);
             current.set(session.sessionId, value);
@@ -126,11 +116,11 @@ export class HistoryService {
           return [...current.values()];
         });
       }
-      if (importedPrevious) this.previousFiles = undefined;
     } catch (error) { warning(this.files.host, error); }
-    records.push(...known.map(record => ({ host: this.files.host, record })));
+    records.push(...known.map(record => ({ host: record.host, record })));
     if (this.otherFiles) {
-      try { records.push(...this.otherFiles.list().map(record => ({ host: this.otherFiles!.host, record }))); }
+      try { this.otherFiles.migrate(this.root); } catch (error) { warning(this.otherFiles.host, error); }
+      try { records.push(...this.otherFiles.list().map(record => ({ host: record.host, record }))); }
       catch (error) { warning(this.otherFiles.host, error); }
     }
     this.check(); signal?.throwIfAborted(); this.#records = records; this.#sourceWarnings = warnings; this.#loaded = true;

package/src/services/workspace/workspace-config.ts

@@ -0,0 +1,49 @@
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { object } from "../../common/json.js";
+import { readJsonFile, writeJsonFile } from "../../storage/atomic-json.js";
+
+function config(value: unknown): Record<string, unknown> {
+  if (!object(value) || value.enabled !== undefined && typeof value.enabled !== "boolean") {
+    throw new Error("配置必须是 JSON 对象，enabled 必须是布尔值。");
+  }
+  return value;
+}
+import type { WorkspaceConfig, WorkspaceConfiguration } from "../../model/workspace-config.js";
+
+export function workspaceConfigPath(root: string): string {
+  return join(root, ".pbot", "config.json");
+}
+
+/** Read only this workspace's configuration; parent directories never grant activation. */
+export async function readWorkspaceConfig(root: string): Promise<WorkspaceConfiguration> {
+  const path = workspaceConfigPath(root);
+  let content: string;
+  try { content = await readFile(path, "utf8"); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { path, present: false, enabled: false };
+    return { path, present: true, enabled: false, error: `无法读取工作区配置 ${path}: ${String(error)}` };
+  }
+  try {
+    const value = config(JSON.parse(content));
+    return { path, present: true, enabled: (value as WorkspaceConfig).enabled === true };
+  } catch (error) {
+    return { path, present: true, enabled: false, error: `工作区配置无效 ${path}: ${String(error)}` };
+  }
+}
+
+/** Explicit init opts in this workspace while preserving its other configuration fields. */
+export async function initializeWorkspaceConfig(root: string): Promise<void> {
+  const current = await readWorkspaceConfig(root);
+  if (current.error) throw new Error(current.error);
+  if (current.enabled) return;
+  const directory = dirname(current.path);
+  await mkdir(directory, { recursive: true });
+  const value = current.present ? readJsonFile(directory, "config.json", config) : {};
+  const written = writeJsonFile(directory, "config.json", { ...value, enabled: true }, config, !current.present);
+  if (!written) await initializeWorkspaceConfig(root);
+}
+
+export function workspaceDisabledMessage(configuration: WorkspaceConfiguration): string {
+  return configuration.error ?? `Personal Bot 未在此工作区启用。请执行 /pbot init 初始化并启用；配置文件：${configuration.path}`;
+}

package/src/services/workspace/workspace-preparation.ts

@@ -2,6 +2,14 @@ import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { requireThat } from "../../common/validation.js";
 import { resourceRoot } from "../../common/paths.js";
+import { initializeWorkspaceConfig, readWorkspaceConfig } from "./workspace-config.js";
+
+export async function initializeWorkspace(root: string): Promise<void> {
+  const configuration = await readWorkspaceConfig(root);
+  if (configuration.error) throw new Error(configuration.error);
+  await prepareWorkspace(root);
+  await initializeWorkspaceConfig(root);
+}
 
 export const directories = ["areas", "projects", "knowledge", "providers", "scratch", "agents"];
 export async function prepareWorkspace(root: string) {

package/src/storage/history-files.ts

@@ -1,14 +1,15 @@
-import { existsSync, mkdirSync, readdirSync, rmdirSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readdirSync, rmdirSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
 import type { HistoryHost, HistoryRecord } from "../model/history.js";
-import { object } from "../common/json.js";
+import { canonical, object } from "../common/json.js";
 import { requireThat } from "../common/validation.js";
-import { readJsonFile, writeJsonFile } from "./atomic-json.js";
+import { internalPath, readJsonFile, syncDirectory, writeJsonFile } from "./atomic-json.js";
 import { fileId } from "./file-access.js";
 
 const strings = (value: unknown): value is string[] => Array.isArray(value) && value.every(item => typeof item === "string");
 function record(value: unknown): HistoryRecord {
-  requireThat(object(value) && typeof value.id === "string" && typeof value.sessionId === "string" &&
+  requireThat(object(value) && (value.host === "pi" || value.host === "dsh") &&
+    typeof value.id === "string" && typeof value.sessionId === "string" &&
     typeof value.name === "string" && Array.isArray(value.nodes), "历史索引无效。");
   for (const node of value.nodes) requireThat(object(node) && typeof node.id === "string" &&
     ["session", "exchange", "summary"].includes(String(node.kind)) && Number.isInteger(node.level) &&
@@ -20,21 +21,58 @@ function record(value: unknown): HistoryRecord {
   return result;
 }
 export class HistoryFiles {
+  #warnings: string[] = [];
   constructor(readonly directory: string, readonly host: HistoryHost = "pi") {}
-  list(workspace?: string) {
+  get warnings(): readonly string[] { return this.#warnings; }
+  list() {
+    this.#warnings = [];
     if (!existsSync(this.directory)) return [];
-    return readdirSync(this.directory).filter(name => name.endsWith(".json"))
-      .map(name => readJsonFile(this.directory, name, value => {
-        const result = record(value);
-        requireThat(this.host !== "dsh" || result.id.startsWith("dsh-"), "dsh 历史根 ID 缺少来源前缀。");
-        return result;
-      }))
-      .filter(value => workspace === undefined || ("workspace" in value && value.workspace === workspace));
+    const records: HistoryRecord[] = [];
+    for (const name of readdirSync(this.directory).filter(name => name.endsWith(".json"))) {
+      try {
+        const value = readJsonFile(this.directory, name, record);
+        requireThat(name === fileId(value.id) + ".json", "历史文件名与根 ID 不匹配。");
+        if (value.host === this.host) records.push(value);
+      } catch (error) { this.#warnings.push(join(this.directory, name) + ": " + String(error)); }
+    }
+    return records;
+  }
+  /** Publish each legacy archive with its directory's host before removing the old copy. */
+  migrate(root: string) {
+    const directory = join(root, "." + this.host, "pbot/history");
+    if (!existsSync(directory)) return;
+    this.control(() => {
+      if (!existsSync(directory)) return;
+      const legacyLock = join(directory, ".write");
+      mkdirSync(legacyLock, { mode: 0o700 });
+      try {
+        for (const name of readdirSync(directory).filter(name => name.endsWith(".json"))) {
+          const source = internalPath(directory, name), target = internalPath(this.directory, name);
+          requireThat(source !== target, "新旧历史目录指向同一位置。");
+          const value = readJsonFile(directory, name, value => {
+            requireThat(object(value) && (value.host === undefined || value.host === this.host), "旧历史归档与来源目录不匹配。");
+            return record({ ...value, host: this.host });
+          });
+          requireThat(name === fileId(value.id) + ".json", "历史文件名与根 ID 不匹配。");
+          if (!writeJsonFile(this.directory, name, value, record, true)) {
+            requireThat(canonical(readJsonFile(this.directory, name, record)) === canonical(value),
+              "历史归档迁移冲突，请核对新旧文件：" + name);
+          }
+          syncDirectory(this.directory);
+          unlinkSync(source); syncDirectory(directory);
+        }
+      } finally { rmdirSync(legacyLock); }
+      rmdirSync(directory);
+      const parent = dirname(directory);
+      syncDirectory(parent);
+      try { rmdirSync(parent); syncDirectory(dirname(parent)); }
+      catch (error) { if (!["ENOTEMPTY", "EEXIST"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error; }
+    });
   }
   /** The callback is synchronous: no SDK reads or model work can hold this source's write lock. */
   control<T>(operation: () => T): T {
     mkdirSync(this.directory, { recursive: true, mode: 0o700 });
-    const lock = join(this.directory, ".write");
+    const lock = join(this.directory, ".write-" + this.host);
     try { mkdirSync(lock, { mode: 0o700 }); }
     catch (error) {
       if ((error as NodeJS.ErrnoException).code === "EEXIST") throw Object.assign(new Error("历史来源写锁被占用：" + this.host), { code: "PBOT_HISTORY_BUSY" });
@@ -43,7 +81,7 @@ export class HistoryFiles {
     try { return operation(); } finally { rmdirSync(lock); }
   }
   save(value: HistoryRecord) {
-    requireThat(this.host !== "dsh" || value.id.startsWith("dsh-"), "dsh 历史根 ID 缺少来源前缀。");
+    requireThat(value.host === this.host, "历史归档与来源不匹配。");
     mkdirSync(this.directory, { recursive: true, mode: 0o700 });
     writeJsonFile(this.directory, fileId(value.id) + ".json", value, record);
   }

package/src/ui/dsh/management.ts

@@ -48,6 +48,7 @@ export function showManagement(ctx: Context, parentSessionId: SessionId) {
   }
   function form(parent: HTMLElement) { const node = element("form"); parent.append(node); return node; }
   function activate(id: string) {
+    if (snapshot?.enabled === false && id !== "status") return;
     tab = id;
     for (const [key, section] of sections) section.hidden = key !== id;
     for (const [key, item] of tabs) { item.setAttribute("aria-selected", String(key === id)); item.tabIndex = key === id ? 0 : -1; }
@@ -88,7 +89,7 @@ export function showManagement(ctx: Context, parentSessionId: SessionId) {
   const status = section("status", "工作区"); pageTitle(status, "工作区", "");
   const counts = note(""), workspaceInfo = group(status); status.querySelector("header")!.after(counts); counts.classList.add("pbot-counts");
   const materials = group(status, "pbot-setting"); materials.append(element("h3", "资料目录"));
-  button(materials, "准备目录", async () => { await command("init", undefined, "资料目录已准备。"); });
+  const initializeButton = button(materials, "准备目录", async () => { await command("init", undefined, "工作区已初始化并启用。"); });
   const pythonCard = group(status, "pbot-setting"), pythonInfo = group(pythonCard);
   const pythonButton = button(pythonCard, "准备 Python", async () => { await command("python setup", undefined, "Python 准备完成。"); });
   const diagnostic = details(status, "环境详情"), statusBody = block(""); statusBody.classList.add("pbot-raw"); diagnostic.append(statusBody);
@@ -367,12 +368,28 @@ export function showManagement(ctx: Context, parentSessionId: SessionId) {
   function renderSnapshot() {
     if (!snapshot) return;
     location.textContent = text(snapshot.workspaceRoot).split(/[\\/]/).filter(Boolean).at(-1) ?? ""; location.title = text(snapshot.workspaceRoot);
+    if (snapshot.enabled === false) {
+      const configuration = record(snapshot.configuration);
+      counts.textContent = configuration.error ? "Personal Bot 配置错误" : "Personal Bot 未启用";
+      workspaceInfo.replaceChildren(facts([["状态", configuration.error ? "配置错误" : "未启用"], ["工作区", snapshot.workspaceRoot], ["配置文件", configuration.path]]),
+        note(configuration.error ? "修复配置文件后执行 /pbot init。" : "执行 /pbot init，或点击下方按钮初始化并启用。"));
+      pythonInfo.replaceChildren(note("启用工作区后自动准备共享 Python 环境。"));
+      materials.hidden = false; initializeButton.textContent = "初始化并启用";
+      enabled(initializeButton, !configuration.error);
+      for (const [id, control] of tabs) enabled(control, id === "status");
+      enabled(pythonButton, false); activate("status");
+      statusBody.textContent = JSON.stringify(snapshot, null, 2);
+      if (configuration.error) inform(text(configuration.error), "error");
+      return;
+    }
+    for (const control of tabs.values()) enabled(control, true);
+    materials.hidden = false; initializeButton.textContent = "准备目录"; enabled(initializeButton, true);
     const agents = rows(snapshot.agents), teams = rows(snapshot.teams), python = record(snapshot.python), history = record(snapshot.history);
     tabCounts.get("experts")!.textContent = text(agents.length); tabCounts.get("teams")!.textContent = text(teams.length);
     const active = agents.filter(agent => ["starting", "busy", "stopping"].includes(text(agent.state))).length;
-    counts.textContent = `专家 ${agents.length} · 执行中 ${active} · 团队 ${teams.length}`;
+    counts.textContent = `Personal Bot 已启动 · 专家 ${agents.length} · 执行中 ${active} · 团队 ${teams.length}`;
     const model = object(snapshot.model) ? snapshot.model : {};
-    workspaceInfo.replaceChildren(facts([["工作区", snapshot.workspaceRoot], ["模型", model.model || "尚未选择"], ["Provider", model.provider || "—"],
+    workspaceInfo.replaceChildren(facts([["状态", "已启动"], ["工作区", snapshot.workspaceRoot], ["配置文件", record(snapshot.configuration).path], ["模型", model.model || "尚未选择"], ["Provider", model.provider || "—"],
       ["历史", history.organizing ? "整理中" : history.pending === null ? "查询时更新索引" : `${history.pending} 项待整理`]]));
     pythonInfo.replaceChildren(element("h3", "Python"), badge(python.state));
     if (python.error) pythonInfo.append(element("p", text(python.error), "pbot-warning"));