personal-bot 0.2.9 → 0.2.10

package/lib/extension/dsh/command.js

@@ -1,12 +1,11 @@
 import { Type } from "../../common/typebox.js";
 import { object, json } from "../../common/json.js";
 import { requireThat, schema } from "../../common/validation.js";
-import { prepareWorkspace } from "../../services/workspace/workspace-preparation.js";
 import { executeAgent } 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 } from "./management.js";
+import { dshWorkspaceStatus } from "./management.js";
 const validAgent = schema(dshAgentActionSchema), validTeam = schema(teamActionSchema), validMessage = schema(teamMessageActionSchema);
 const chatSchema = Type.Object({ agentId: Type.String({ minLength: 1 }), text: Type.Optional(Type.String({ maxLength: 24000 })),
     delivery: Type.Optional(Type.Union([Type.Literal("steer"), Type.Literal("followUp")])),
@@ -18,23 +17,28 @@ export function registerDshCommand(ctx, workspaces, management) {
         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 = JSON.parse(command.slice(split));
             requireThat(object(input), "命令参数必须是 JSON 对象。");

package/lib/extension/dsh/history.js

@@ -17,7 +17,7 @@ export class DshHistoryWork {
     constructor(ctx, root) {
         this.ctx = ctx;
         const agents = new AgentFiles(dshHomePath("pbot", "subagents"), "dsh");
-        this.service = new HistoryService(root, new HistoryFiles(join(root, ".dsh/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")));
+        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)), new HistoryFiles(join(root, ".pbot/history")));
     }
     attach(agent) { this.#parents.add(agent); return () => { this.#parents.delete(agent); }; }
     cancel() { this.#controller?.abort(); }

package/lib/extension/dsh/management.d.ts

@@ -1,12 +1,16 @@
+import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { Context } from "@deepseek-ai/cordis";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { type Json } from "../../common/json.js";
 import type { DshWorkspaces, DshWorkspace } from "./workspace.js";
 export declare function dshStatus(workspaces: DshWorkspaces, workspace: DshWorkspace): Json;
+/** Status remains available when this workspace has not opted in. */
+export declare function dshWorkspaceStatus(workspaces: DshWorkspaces, agent: Agent): Promise<Json>;
 /** Native Remote owns transport and access checks. These workspace reads do not admit or cancel execution. */
 export declare class PbotManagement extends TypertRemoteService {
     private readonly workspaces;
     constructor(ctx: Context, workspaces: DshWorkspaces);
+    private parent;
     private workspace;
     snapshot(request: Json, signal: AbortSignal): Promise<Json>;
     expert(request: Json, signal: AbortSignal): Promise<Json>;

package/lib/extension/dsh/management.js

@@ -106,11 +106,20 @@ const validRequest = schema(requestSchema), validExpert = schema(expertSchema),
 export function dshStatus(workspaces, workspace) {
     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, agent) {
+    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)), configuration });
+}
 /** Native Remote owns transport and access checks. These workspace reads do not admit or cancel execution. */
 let PbotManagement = (() => {
     let _classSuper = TypertRemoteService;
@@ -137,21 +146,27 @@ let PbotManagement = (() => {
             super(ctx, "pbotManagement", { namespace: "pbot" });
             this.workspaces = workspaces;
         }
-        async workspace(request, signal) {
+        parent(request, signal) {
             signal.throwIfAborted();
             requireThat(validRequest(request), "管理查询参数无效。");
             const args = request;
             const agent = this.ctx.agents.get(SessionId(args.parentSessionId));
             requireThat(agent, "父会话未加载或已关闭，请在原生会话页面重新打开。");
+            return { agent, input: args.input };
+        }
+        async workspace(request, signal) {
+            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]) };
         }
         async snapshot(request, signal) {
-            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;
         }
         async expert(request, signal) {
             const env_1 = { stack: [], error: void 0, hasError: false };

package/lib/extension/dsh/workspace.d.ts

@@ -8,6 +8,7 @@ import { DshAgentRuntime } from "./agent-runtime.js";
 import { DshHistoryWork } from "./history.js";
 import type { HistoryService } from "../../services/history/history-service.js";
 import { PythonEnvironmentService } from "../../services/workspace/python-environment-service.js";
+import type { WorkspaceConfiguration } from "../../model/workspace-config.js";
 export declare const dshDependencies: string[];
 export declare class DshWorkspace {
     #private;
@@ -38,8 +39,13 @@ export declare class DshWorkspaces {
     readonly python: PythonEnvironmentService;
     constructor(ctx: Context);
     private history;
-    open(agent: Agent): Promise<DshWorkspace>;
+    open(agent: Agent): Promise<DshWorkspace | undefined>;
     get(agent: Agent): Promise<DshWorkspace>;
+    configuration(agent: Agent): Promise<{
+        root: string;
+        configuration: WorkspaceConfiguration;
+    }>;
+    initialize(agent: Agent): Promise<DshWorkspace>;
     preparePython(): Promise<{
         directory: string;
         python: string;

package/lib/extension/dsh/workspace.js

@@ -14,6 +14,9 @@ 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 { initializeWorkspace } from "../../services/workspace/workspace-preparation.js";
 export const dshDependencies = ["agents", "sessions", "sessionPersistence", "sessionQuery", "llm", "tools", "systemPrompt", "skills", "fs", "attachments", "workingDirectory", "approval"];
 export class DshWorkspace {
     ctx;
@@ -52,6 +55,7 @@ export class DshWorkspace {
                         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)
@@ -77,6 +81,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);
@@ -152,6 +157,8 @@ export class DshWorkspaces {
     ctx;
     python = new PythonEnvironmentService(process.cwd());
     #parents = new Map();
+    #initializing = new Map();
+    #configurations = new Map();
     #parentEffects = new Map();
     #histories = new Map();
     #lifetime = new AbortController();
@@ -202,6 +209,20 @@ 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;
             try {
@@ -209,12 +230,14 @@ export class DshWorkspaces {
                 const owned = workspace;
                 const dispose = agent.ctx.effect(() => async () => {
                     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();
+                void this.preparePython().catch(error => this.ctx.logger.warn(String(error)));
                 return workspace;
             }
             catch (error) {
@@ -246,9 +269,51 @@ 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) {
+        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) {
+        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)
@@ -268,8 +333,9 @@ 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();
@@ -279,6 +345,7 @@ export class DshWorkspaces {
             }
             finally {
                 this.#parents.clear();
+                this.#configurations.clear();
                 this.#parentEffects.clear();
                 this.#histories.clear();
                 this.#restorePython?.();

package/lib/extension/setup-cli.js

@@ -115,7 +115,7 @@ export async function main(args) {
         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);
         }

package/lib/integrations/dsh/skills.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+/** Keep bundled methods local to this Agent without overriding its native project/user methods. */
+export declare function registerDshSkills(ctx: Context, agent: Agent): void;

package/lib/integrations/dsh/skills.js

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+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, agent) {
+    let filesystem;
+    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/lib/model/history.d.ts

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

package/lib/model/workspace-config.d.ts

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

package/lib/model/workspace-config.js

@@ -0,0 +1 @@
+export {};

package/lib/services/history/history-service.d.ts

@@ -18,9 +18,8 @@ export declare class HistoryService {
     readonly root: string;
     private readonly files;
     private readonly source;
-    private previousFiles?;
     private readonly otherFiles?;
-    constructor(root: string, files: HistoryFiles, source: HistorySource, previousFiles?: HistoryFiles | undefined, otherFiles?: HistoryFiles | undefined);
+    constructor(root: string, files: HistoryFiles, source: HistorySource, otherFiles?: HistoryFiles | undefined);
     check(): void;
     get warnings(): string[];
     get status(): {

package/lib/services/history/history-service.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { requireThat } from "../../common/validation.js";
 /** Shared prefixes reuse nodes; only consecutive exchanges on one native branch can merge. */
-export function indexHistory(session, previous, host = "pi") {
+export function indexHistory(session, previous, host = previous?.host ?? "pi") {
     const id = previous?.id ?? (host === "dsh" ? "dsh-" : "") + randomUUID(), nodes = new Map();
     const old = new Map(previous?.nodes.map(node => [node.id, node])), changed = new Set();
     const add = (value, level, children = []) => {
@@ -40,7 +40,7 @@ export function indexHistory(session, previous, host = "pi") {
     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()] };
 }
 const page = (values, offset, limit) => ({ values: values.slice(offset, offset + limit),
     nextOffset: offset + limit < values.length ? offset + limit : null });
@@ -66,7 +66,6 @@ export class HistoryService {
     root;
     files;
     source;
-    previousFiles;
     otherFiles;
     #records = [];
     #closed = false;
@@ -75,17 +74,18 @@ export class HistoryService {
     #work;
     #sourceWarnings = [];
     #summaryError;
-    constructor(root, files, source, previousFiles, otherFiles) {
+    constructor(root, files, source, otherFiles) {
         this.root = root;
         this.files = files;
         this.source = source;
-        this.previousFiles = previousFiles;
         this.otherFiles = otherFiles;
         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 };
@@ -105,18 +105,13 @@ export class HistoryService {
         const warning = (host, error) => { this.check(); signal?.throwIfAborted(); warnings.push(host + ": " + String(error)); };
         let known = [];
         try {
-            const before = this.files.list();
-            known = before;
-            let imports = [], 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 = [];
             try {
                 const scanned = await this.source.scan(location, signal);
@@ -128,32 +123,20 @@ export class HistoryService {
             }
             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();
-                    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))
+                        if (!captured && previous)
                             continue;
                         const value = indexHistory(session, previous, this.files.host);
                         if (JSON.stringify(previous) !== JSON.stringify(value))
@@ -163,16 +146,20 @@ 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 })));
+                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);

package/lib/services/workspace/workspace-config.d.ts

@@ -0,0 +1,7 @@
+import type { WorkspaceConfiguration } from "../../model/workspace-config.js";
+export declare function workspaceConfigPath(root: string): string;
+/** Read only this workspace's configuration; parent directories never grant activation. */
+export declare function readWorkspaceConfig(root: string): Promise<WorkspaceConfiguration>;
+/** Explicit init opts in this workspace while preserving its other configuration fields. */
+export declare function initializeWorkspaceConfig(root: string): Promise<void>;
+export declare function workspaceDisabledMessage(configuration: WorkspaceConfiguration): string;

package/lib/services/workspace/workspace-config.js

@@ -0,0 +1,50 @@
+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) {
+    if (!object(value) || value.enabled !== undefined && typeof value.enabled !== "boolean") {
+        throw new Error("配置必须是 JSON 对象，enabled 必须是布尔值。");
+    }
+    return value;
+}
+export function workspaceConfigPath(root) {
+    return join(root, ".pbot", "config.json");
+}
+/** Read only this workspace's configuration; parent directories never grant activation. */
+export async function readWorkspaceConfig(root) {
+    const path = workspaceConfigPath(root);
+    let content;
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.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.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) {
+    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) {
+    return configuration.error ?? `Personal Bot 未在此工作区启用。请执行 /pbot init 初始化并启用；配置文件：${configuration.path}`;
+}

package/lib/services/workspace/workspace-preparation.d.ts

@@ -1,2 +1,3 @@
+export declare function initializeWorkspace(root: string): Promise<void>;
 export declare const directories: string[];
 export declare function prepareWorkspace(root: string): Promise<void>;

package/lib/services/workspace/workspace-preparation.js

@@ -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) {
+    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) {
     for (const part of directories) {

package/lib/storage/history-files.d.ts

@@ -1,9 +1,13 @@
 import type { HistoryHost, HistoryRecord } from "../model/history.js";
 export declare class HistoryFiles {
+    #private;
     readonly directory: string;
     readonly host: HistoryHost;
     constructor(directory: string, host?: HistoryHost);
-    list(workspace?: string): HistoryRecord[];
+    get warnings(): readonly string[];
+    list(): HistoryRecord[];
+    /** Publish each legacy archive with its directory's host before removing the old copy. */
+    migrate(root: string): void;
     /** The callback is synchronous: no SDK reads or model work can hold this source's write lock. */
     control<T>(operation: () => T): T;
     save(value: HistoryRecord): void;