@bytetrue/byspace 0.2.0-beta.4 → 0.2.0

package/node_modules/@bytetrue/byspace-protocol/dist/messages.d.ts

@@ -1393,6 +1393,15 @@ export declare const DaemonUpdateRequestMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"daemon.update.request">;
     requestId: z.ZodString;
 }, z.core.$strip>;
+export declare const DaemonOrchestrationSkillsGetStatusRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.get_status.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const DaemonOrchestrationSkillsSetInstalledRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.request">;
+    installed: z.ZodBoolean;
+    requestId: z.ZodString;
+}, z.core.$strip>;
 export declare const AgentTimelineCursorSchema: z.ZodObject<{
     epoch: z.ZodString;
     seq: z.ZodNumber;
@@ -3306,6 +3315,13 @@ export declare const SessionInboundMessageSchema: z.ZodDiscriminatedUnion<[z.Zod
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"daemon.update.request">;
     requestId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.get_status.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.request">;
+    installed: z.ZodBoolean;
+    requestId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"fetch_agent_timeline_request">;
     agentId: z.ZodString;
@@ -4435,6 +4451,7 @@ export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
         daemonStatusRpc: z.ZodOptional<z.ZodBoolean>;
         "terminal-restore-modes": z.ZodOptional<z.ZodBoolean>;
         terminalAgentHookProviders: z.ZodOptional<z.ZodBoolean>;
+        orchestrationSkills: z.ZodOptional<z.ZodBoolean>;
         rewind: z.ZodOptional<z.ZodBoolean>;
         checkoutRefresh: z.ZodOptional<z.ZodBoolean>;
         workspaceMultiplicity: z.ZodOptional<z.ZodBoolean>;
@@ -4486,6 +4503,7 @@ export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
         daemonStatusRpc?: boolean | undefined;
         "terminal-restore-modes"?: boolean | undefined;
         terminalAgentHookProviders?: boolean | undefined;
+        orchestrationSkills?: boolean | undefined;
         rewind?: boolean | undefined;
         checkoutRefresh?: boolean | undefined;
         workspaceMultiplicity?: boolean | undefined;
@@ -4538,6 +4556,7 @@ export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
         daemonStatusRpc?: boolean | undefined;
         "terminal-restore-modes"?: boolean | undefined;
         terminalAgentHookProviders?: boolean | undefined;
+        orchestrationSkills?: boolean | undefined;
         rewind?: boolean | undefined;
         checkoutRefresh?: boolean | undefined;
         workspaceMultiplicity?: boolean | undefined;
@@ -11646,6 +11665,36 @@ export declare const DaemonUpdateResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type DaemonUpdateResponse = z.infer<typeof DaemonUpdateResponseSchema>;
+export declare const OrchestrationSkillsStateSchema: z.ZodEnum<{
+    "not-installed": "not-installed";
+    "up-to-date": "up-to-date";
+    drift: "drift";
+}>;
+export type OrchestrationSkillsState = z.infer<typeof OrchestrationSkillsStateSchema>;
+export declare const DaemonOrchestrationSkillsGetStatusResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.get_status.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        state: z.ZodEnum<{
+            "not-installed": "not-installed";
+            "up-to-date": "up-to-date";
+            drift: "drift";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DaemonOrchestrationSkillsGetStatusResponse = z.infer<typeof DaemonOrchestrationSkillsGetStatusResponseSchema>;
+export declare const DaemonOrchestrationSkillsSetInstalledResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        state: z.ZodEnum<{
+            "not-installed": "not-installed";
+            "up-to-date": "up-to-date";
+            drift: "drift";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DaemonOrchestrationSkillsSetInstalledResponse = z.infer<typeof DaemonOrchestrationSkillsSetInstalledResponseSchema>;
 export declare const DaemonUpdateProgressMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"daemon.update.progress">;
     payload: z.ZodObject<{
@@ -14929,6 +14978,26 @@ export declare const SessionOutboundMessageSchema: z.ZodDiscriminatedUnion<[z.Zo
         requestId: z.ZodString;
         diagnostic: z.ZodString;
     }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.get_status.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        state: z.ZodEnum<{
+            "not-installed": "not-installed";
+            "up-to-date": "up-to-date";
+            drift: "drift";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        state: z.ZodEnum<{
+            "not-installed": "not-installed";
+            "up-to-date": "up-to-date";
+            drift: "drift";
+        }>;
+    }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"get_daemon_config_response">;
     payload: z.ZodObject<{
@@ -19207,6 +19276,13 @@ export declare const WSSessionInboundSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"daemon.update.request">;
         requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.get_status.request">;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.request">;
+        installed: z.ZodBoolean;
+        requestId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"fetch_agent_timeline_request">;
         agentId: z.ZodString;
@@ -23445,6 +23521,26 @@ export declare const WSSessionOutboundSchema: z.ZodObject<{
             requestId: z.ZodString;
             diagnostic: z.ZodString;
         }, z.core.$loose>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.get_status.response">;
+        payload: z.ZodObject<{
+            requestId: z.ZodString;
+            state: z.ZodEnum<{
+                "not-installed": "not-installed";
+                "up-to-date": "up-to-date";
+                drift: "drift";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.response">;
+        payload: z.ZodObject<{
+            requestId: z.ZodString;
+            state: z.ZodEnum<{
+                "not-installed": "not-installed";
+                "up-to-date": "up-to-date";
+                drift: "drift";
+            }>;
+        }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"get_daemon_config_response">;
         payload: z.ZodObject<{
@@ -27408,6 +27504,13 @@ export declare const WSInboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"daemon.update.request">;
         requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.get_status.request">;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.request">;
+        installed: z.ZodBoolean;
+        requestId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"fetch_agent_timeline_request">;
         agentId: z.ZodString;
@@ -31648,6 +31751,26 @@ export declare const WSOutboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             requestId: z.ZodString;
             diagnostic: z.ZodString;
         }, z.core.$loose>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.get_status.response">;
+        payload: z.ZodObject<{
+            requestId: z.ZodString;
+            state: z.ZodEnum<{
+                "not-installed": "not-installed";
+                "up-to-date": "up-to-date";
+                drift: "drift";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"daemon.orchestration_skills.set_installed.response">;
+        payload: z.ZodObject<{
+            requestId: z.ZodString;
+            state: z.ZodEnum<{
+                "not-installed": "not-installed";
+                "up-to-date": "up-to-date";
+                drift: "drift";
+            }>;
+        }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"get_daemon_config_response">;
         payload: z.ZodObject<{

package/node_modules/@bytetrue/byspace-protocol/dist/messages.js

@@ -1094,6 +1094,15 @@ export const DaemonUpdateRequestMessageSchema = z.object({
     type: z.literal("daemon.update.request"),
     requestId: z.string(),
 });
+export const DaemonOrchestrationSkillsGetStatusRequestSchema = z.object({
+    type: z.literal("daemon.orchestration_skills.get_status.request"),
+    requestId: z.string(),
+});
+export const DaemonOrchestrationSkillsSetInstalledRequestSchema = z.object({
+    type: z.literal("daemon.orchestration_skills.set_installed.request"),
+    installed: z.boolean(),
+    requestId: z.string(),
+});
 export const AgentTimelineCursorSchema = z.object({
     epoch: z.string(),
     seq: z.number().int().nonnegative(),
@@ -1989,6 +1998,8 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ShutdownServerRequestMessageSchema,
     RestartServerRequestMessageSchema,
     DaemonUpdateRequestMessageSchema,
+    DaemonOrchestrationSkillsGetStatusRequestSchema,
+    DaemonOrchestrationSkillsSetInstalledRequestSchema,
     FetchAgentTimelineRequestMessageSchema,
     ProviderSubagentListRequestMessageSchema,
     ProviderSubagentTimelineRequestMessageSchema,
@@ -2244,6 +2255,8 @@ export const ServerInfoStatusPayloadSchema = z
         "terminal-restore-modes": z.boolean().optional(),
         // COMPAT(terminalAgentHookProviders): added in v0.2.0, remove gate after 2027-01-21.
         terminalAgentHookProviders: z.boolean().optional(),
+        // COMPAT(orchestrationSkills): added in v0.2.0-beta.5, remove gate after 2027-01-22.
+        orchestrationSkills: z.boolean().optional(),
         // COMPAT(rewind): added in v0.1.X, drop the gate when floor >= v0.1.X.
         rewind: z.boolean().optional(),
         // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.
@@ -4174,6 +4187,21 @@ export const DaemonUpdateResponseSchema = z.object({
         newVersion: z.string().nullable(),
     }),
 });
+export const OrchestrationSkillsStateSchema = z.enum(["not-installed", "up-to-date", "drift"]);
+export const DaemonOrchestrationSkillsGetStatusResponseSchema = z.object({
+    type: z.literal("daemon.orchestration_skills.get_status.response"),
+    payload: z.object({
+        requestId: z.string(),
+        state: OrchestrationSkillsStateSchema,
+    }),
+});
+export const DaemonOrchestrationSkillsSetInstalledResponseSchema = z.object({
+    type: z.literal("daemon.orchestration_skills.set_installed.response"),
+    payload: z.object({
+        requestId: z.string(),
+        state: OrchestrationSkillsStateSchema,
+    }),
+});
 export const DaemonUpdateProgressMessageSchema = z.object({
     type: z.literal("daemon.update.progress"),
     payload: z.object({
@@ -4231,6 +4259,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     DaemonGetStatusResponseSchema,
     DaemonGetPairingOfferResponseSchema,
     DiagnosticsResponseSchema,
+    DaemonOrchestrationSkillsGetStatusResponseSchema,
+    DaemonOrchestrationSkillsSetInstalledResponseSchema,
     GetDaemonConfigResponseMessageSchema,
     SetDaemonConfigResponseMessageSchema,
     ReadProjectConfigResponseMessageSchema,

package/node_modules/@bytetrue/byspace-protocol/dist/validation/ws-outbound-schema-metadata.d.ts

@@ -3273,6 +3273,26 @@ export declare const WSOutboundMessageSchema: {
                 requestId: import("zod").ZodString;
                 diagnostic: import("zod").ZodString;
             }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"daemon.orchestration_skills.get_status.response">;
+            payload: import("zod").ZodObject<{
+                requestId: import("zod").ZodString;
+                state: import("zod").ZodEnum<{
+                    "not-installed": "not-installed";
+                    "up-to-date": "up-to-date";
+                    drift: "drift";
+                }>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"daemon.orchestration_skills.set_installed.response">;
+            payload: import("zod").ZodObject<{
+                requestId: import("zod").ZodString;
+                state: import("zod").ZodEnum<{
+                    "not-installed": "not-installed";
+                    "up-to-date": "up-to-date";
+                    drift: "drift";
+                }>;
+            }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"get_daemon_config_response">;
             payload: import("zod").ZodObject<{

package/node_modules/@bytetrue/byspace-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/byspace-protocol",
-  "version": "0.2.0-beta.4",
+  "version": "0.2.0",
   "private": true,
   "description": "BySpace shared protocol schemas and wire types",
   "files": [

package/node_modules/@bytetrue/byspace-relay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytetrue/byspace-relay",
-  "version": "0.2.0-beta.4",
+  "version": "0.2.0",
   "private": true,
   "description": "BySpace relay for bridging daemon and client connections",
   "files": [

package/node_modules/@bytetrue/byspace-server/dist/server/server/config.js

@@ -176,7 +176,7 @@ function resolveWebUiConfig(byspaceHome, env, cli, persisted) {
     const enabled = cli?.webUiEnabled ??
         parseBooleanEnv(env.BYSPACE_WEB_UI_ENABLED) ??
         persisted.features?.webUi?.enabled ??
-        false;
+        true;
     const rawDistDir = env.BYSPACE_WEB_UI_DIST_DIR ?? persisted.features?.webUi?.distDir;
     const trimmedDistDir = rawDistDir?.trim();
     const distDir = trimmedDistDir

package/node_modules/@bytetrue/byspace-server/dist/server/server/orchestration-skills.d.ts

@@ -0,0 +1,11 @@
+export declare const BYSPACE_ORCHESTRATION_SKILL_NAMES: readonly ["byspace", "byspace-advisor", "byspace-committee", "byspace-handoff", "byspace-loop"];
+export type OrchestrationSkillsState = "not-installed" | "up-to-date" | "drift";
+export interface OrchestrationSkillsTargets {
+    sourceDir: string;
+    installDirs: readonly string[];
+    manifestPath: string;
+}
+export declare function resolveOrchestrationSkillsTargets(byspaceHome: string): OrchestrationSkillsTargets;
+export declare function getOrchestrationSkillsStatus(targets: OrchestrationSkillsTargets): Promise<OrchestrationSkillsState>;
+export declare function setOrchestrationSkillsInstalled(installed: boolean, targets: OrchestrationSkillsTargets): Promise<OrchestrationSkillsState>;
+//# sourceMappingURL=orchestration-skills.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/orchestration-skills.js

@@ -0,0 +1,197 @@
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeJsonFileAtomic } from "./atomic-file.js";
+export const BYSPACE_ORCHESTRATION_SKILL_NAMES = [
+    "byspace",
+    "byspace-advisor",
+    "byspace-committee",
+    "byspace-handoff",
+    "byspace-loop",
+];
+export function resolveOrchestrationSkillsTargets(byspaceHome) {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packagedSourceDir = path.resolve(moduleDir, "../../skills");
+    const checkoutSourceDir = path.resolve(moduleDir, "../../../../skills");
+    const home = os.homedir();
+    return {
+        sourceDir: process.env.BYSPACE_NODE_ENV === "development" ? checkoutSourceDir : packagedSourceDir,
+        installDirs: [path.join(home, ".agents", "skills"), path.join(home, ".claude", "skills")],
+        manifestPath: path.join(byspaceHome, "managed-orchestration-skills.json"),
+    };
+}
+async function hashDirectory(directory) {
+    const stat = await fs.lstat(directory).catch(() => null);
+    if (!stat)
+        return null;
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`Orchestration skill path must be a directory: ${directory}`);
+    }
+    const hash = createHash("sha256");
+    async function walk(current) {
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            const relativePath = path.relative(directory, fullPath).split(path.sep).join("/");
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                hash.update(relativePath);
+                hash.update("\0");
+                hash.update(await fs.readFile(fullPath));
+                hash.update("\0");
+            }
+            else {
+                throw new Error(`Unsupported file in orchestration skill: ${fullPath}`);
+            }
+        }
+    }
+    await walk(directory);
+    return hash.digest("hex");
+}
+async function readManifest(manifestPath) {
+    const raw = await fs.readFile(manifestPath, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    });
+    if (raw === null)
+        return { version: 1, managed: {} };
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        parsed.version !== 1 ||
+        typeof parsed.managed !== "object" ||
+        parsed.managed === null) {
+        throw new Error(`Invalid orchestration skills manifest: ${manifestPath}`);
+    }
+    const managed = parsed.managed;
+    if (Object.values(managed).some((digest) => typeof digest !== "string")) {
+        throw new Error(`Invalid orchestration skills manifest: ${manifestPath}`);
+    }
+    return { version: 1, managed: managed };
+}
+async function writeManifest(manifestPath, manifest) {
+    await writeJsonFileAtomic(manifestPath, manifest);
+    await fs.chmod(manifestPath, 0o600);
+}
+export async function getOrchestrationSkillsStatus(targets) {
+    let installedCount = 0;
+    let hasDrift = false;
+    for (const name of BYSPACE_ORCHESTRATION_SKILL_NAMES) {
+        const sourceHash = await hashDirectory(path.join(targets.sourceDir, name));
+        if (!sourceHash)
+            throw new Error(`Bundled orchestration skill is missing: ${name}`);
+        const installedHashes = await Promise.all(targets.installDirs.map((directory) => hashDirectory(path.join(directory, name))));
+        installedCount += installedHashes.filter((hash) => hash !== null).length;
+        hasDrift || (hasDrift = installedHashes.some((hash) => hash !== sourceHash));
+    }
+    if (installedCount === 0)
+        return "not-installed";
+    return hasDrift ? "drift" : "up-to-date";
+}
+async function replaceDirectory(source, destination) {
+    const parent = path.dirname(destination);
+    const suffix = `${process.pid}-${randomUUID()}`;
+    const staged = path.join(parent, `.${path.basename(destination)}.${suffix}.tmp`);
+    const backup = path.join(parent, `.${path.basename(destination)}.${suffix}.bak`);
+    await fs.mkdir(parent, { recursive: true });
+    await fs.cp(source, staged, { recursive: true, errorOnExist: true, force: false });
+    const destinationExists = (await fs.lstat(destination).catch(() => null)) !== null;
+    let originalMoved = false;
+    let installed = false;
+    try {
+        if (destinationExists) {
+            await fs.rename(destination, backup);
+            originalMoved = true;
+        }
+        await fs.rename(staged, destination);
+        installed = true;
+    }
+    catch (error) {
+        if (originalMoved && !installed) {
+            try {
+                await fs.rename(backup, destination);
+            }
+            catch (rollbackError) {
+                throw new Error(`Failed to replace orchestration skill and restore backup: ${destination}. Replacement error: ${error instanceof Error ? error.message : String(error)}`, { cause: rollbackError });
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (!installed)
+            await fs.rm(staged, { recursive: true, force: true }).catch(() => undefined);
+    }
+    if (originalMoved)
+        await fs.rm(backup, { recursive: true, force: true });
+}
+async function installOrUpdateOrchestrationSkills(targets) {
+    const manifest = await readManifest(targets.manifestPath);
+    const nextManaged = {};
+    const pending = [];
+    for (const name of BYSPACE_ORCHESTRATION_SKILL_NAMES) {
+        const source = path.join(targets.sourceDir, name);
+        const digest = await hashDirectory(source);
+        if (!digest)
+            throw new Error(`Bundled orchestration skill is missing: ${name}`);
+        for (const installDir of targets.installDirs) {
+            const destination = path.join(installDir, name);
+            const installedDigest = await hashDirectory(destination);
+            if (installedDigest !== null &&
+                installedDigest !== digest &&
+                !manifest.managed[destination]) {
+                throw new Error(`Refusing to overwrite non-BySpace orchestration skill: ${destination}`);
+            }
+            pending.push({ source, destination, digest });
+            nextManaged[destination] = digest;
+        }
+    }
+    for (const item of pending) {
+        if ((await hashDirectory(item.destination)) !== item.digest) {
+            await replaceDirectory(item.source, item.destination);
+        }
+    }
+    await writeManifest(targets.manifestPath, { version: 1, managed: nextManaged });
+}
+async function uninstallOrchestrationSkills(targets) {
+    const manifest = await readManifest(targets.manifestPath);
+    const pending = [];
+    for (const name of BYSPACE_ORCHESTRATION_SKILL_NAMES) {
+        const sourceDigest = await hashDirectory(path.join(targets.sourceDir, name));
+        if (!sourceDigest)
+            throw new Error(`Bundled orchestration skill is missing: ${name}`);
+        for (const installDir of targets.installDirs) {
+            const destination = path.join(installDir, name);
+            const installedDigest = await hashDirectory(destination);
+            if (installedDigest === null)
+                continue;
+            if (installedDigest !== sourceDigest) {
+                throw new Error(`Refusing to remove modified orchestration skill: ${destination}`);
+            }
+            if (manifest.managed[destination] || installedDigest === sourceDigest)
+                pending.push(destination);
+        }
+    }
+    for (const destination of pending) {
+        await fs.rm(destination, { recursive: true, force: true });
+    }
+    await fs.rm(targets.manifestPath, { force: true });
+}
+let mutationQueue = Promise.resolve();
+export function setOrchestrationSkillsInstalled(installed, targets) {
+    const operation = mutationQueue.then(async () => {
+        if (installed)
+            await installOrUpdateOrchestrationSkills(targets);
+        else
+            await uninstallOrchestrationSkills(targets);
+        return getOrchestrationSkillsStatus(targets);
+    });
+    mutationQueue = operation.then(() => undefined, () => undefined);
+    return operation;
+}
+//# sourceMappingURL=orchestration-skills.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-session.d.ts

@@ -70,6 +70,12 @@ export declare class DaemonSession {
     handleDiagnosticsRequest(msg: Extract<SessionInboundMessage, {
         type: "diagnostics.request";
     }>): Promise<void>;
+    handleOrchestrationSkillsGetStatusRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.orchestration_skills.get_status.request";
+    }>): Promise<void>;
+    handleOrchestrationSkillsSetInstalledRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.orchestration_skills.set_installed.request";
+    }>): Promise<void>;
     handleUpdateRequest(msg: Extract<SessionInboundMessage, {
         type: "daemon.update.request";
     }>): Promise<void>;

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-session.js

@@ -2,6 +2,7 @@ import { getPidLockInfo } from "../../pid-lock.js";
 import { generateLocalPairingOffer } from "../../pairing-offer.js";
 import { collectDaemonDiagnostics, } from "./diagnostics.js";
 import { DaemonSelfUpdateSessionController } from "./daemon-self-update-session-controller.js";
+import { getOrchestrationSkillsStatus, resolveOrchestrationSkillsTargets, setOrchestrationSkillsInstalled, } from "../../orchestration-skills.js";
 /**
  * A client's read surface for the daemon process itself: its runtime status
  * (pid-lock start time, listen address, relay config, provider availability) and
@@ -142,6 +143,20 @@ export class DaemonSession {
             });
         }
     }
+    async handleOrchestrationSkillsGetStatusRequest(msg) {
+        const state = await getOrchestrationSkillsStatus(resolveOrchestrationSkillsTargets(this.byspaceHome));
+        this.host.emit({
+            type: "daemon.orchestration_skills.get_status.response",
+            payload: { requestId: msg.requestId, state },
+        });
+    }
+    async handleOrchestrationSkillsSetInstalledRequest(msg) {
+        const state = await setOrchestrationSkillsInstalled(msg.installed, resolveOrchestrationSkillsTargets(this.byspaceHome));
+        this.host.emit({
+            type: "daemon.orchestration_skills.set_installed.response",
+            payload: { requestId: msg.requestId, state },
+        });
+    }
     async handleUpdateRequest(msg) {
         await this.selfUpdate.dispatch(msg);
     }

package/node_modules/@bytetrue/byspace-server/dist/server/server/session.js

@@ -1017,6 +1017,10 @@ export class Session {
                 return this.daemonSession.handleGetStatusRequest(msg);
             case "daemon.get_pairing_offer.request":
                 return this.daemonSession.handleGetPairingOfferRequest(msg);
+            case "daemon.orchestration_skills.get_status.request":
+                return this.daemonSession.handleOrchestrationSkillsGetStatusRequest(msg);
+            case "daemon.orchestration_skills.set_installed.request":
+                return this.daemonSession.handleOrchestrationSkillsSetInstalledRequest(msg);
             case "diagnostics.request":
                 return this.daemonSession.handleDiagnosticsRequest(msg);
             case "daemon.update.request":

package/node_modules/@bytetrue/byspace-server/dist/server/server/websocket-server.js

@@ -842,6 +842,8 @@ export class VoiceAssistantWebSocketServer {
                 "terminal-restore-modes": true,
                 // COMPAT(terminalAgentHookProviders): added in v0.2.0, remove gate after 2027-01-21.
                 terminalAgentHookProviders: true,
+                // COMPAT(orchestrationSkills): added in v0.2.0-beta.5, remove gate after 2027-01-22.
+                orchestrationSkills: true,
                 // COMPAT(rewind): added in v0.1.X, drop the gate when floor >= v0.1.X.
                 rewind: true,
                 // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.

package/node_modules/@bytetrue/byspace-server/dist/server/terminal/terminal-worker-process.js

@@ -246,11 +246,18 @@ async function handleRequest(message) {
             // snapshot's) the controller's revision dedup wouldn't drop it and the client would
             // see the bytes twice. Flushing first sends them with a revision <= the snapshot's.
             outputCoalescerByTerminalId.get(message.terminalId)?.flush();
+            // Drain the headless xterm so snapshotRevision catches up with emitRevision.
+            // Without this, the snapshot could lag behind already-emitted output and
+            // the controller would replay bytes the client already received.
+            const stateSession = manager.getTerminal(message.terminalId);
+            if (stateSession) {
+                await stateSession.drainHeadlessXterm();
+            }
             sendToParent({
                 type: "response",
                 requestId: message.requestId,
                 ok: true,
-                result: buildTerminalStateResult(manager.getTerminal(message.terminalId), message.options),
+                result: buildTerminalStateResult(stateSession, message.options),
             });
             return;
         }

package/node_modules/@bytetrue/byspace-server/dist/server/terminal/terminal.d.ts

@@ -71,6 +71,7 @@ export interface TerminalSession {
     };
     getState(): TerminalState;
     getStateSnapshot(options?: TerminalStateSnapshotOptions): TerminalStateSnapshot;
+    drainHeadlessXterm(): Promise<void>;
     getReplayPreamble(): string;
     getTitle(): string | undefined;
     getActivity(): TerminalActivity | null;