qlogicagent 2.13.3 → 2.13.5

package/dist/cli/skill-meta-tool-bootstrap.js

@@ -0,0 +1,295 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { invalidateSkillRecallCache } from "../runtime/hooks/skill-recall-hooks.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+import { createSkillMetaTool } from "../skills/tools/skill-tool.js";
+import { loadLifecycleStore, saveLifecycleStore, ensureRecord, recordPatch, removeRecord, } from "../skills/skill-system/skill-lifecycle.js";
+import { validateSkillContent, autoFixFrontmatter } from "../skills/skill-system/skill-validation.js";
+import { resolveSkills, resolveActiveSkills, resolveSkillPath } from "../runtime/infra/skill-resolver.js";
+import { enableSkill, disableSkill, markProjectScoped, unmarkProjectScoped } from "../runtime/infra/project-skill-manifest.js";
+import { executeSkillSubturn } from "./skill-meta-subturn-service.js";
+export { resolveSkillSubagentTypeForLifecycle } from "./skill-meta-subturn-service.js";
+export const skillMetaToolRegistrationModule = defineToolRegistrationModule({
+    id: "skill-meta-tool",
+    kind: "skill",
+    register: ({ host, ...deps }) => configureSkillMetaToolBootstrapInternal(host, deps),
+});
+export function configureSkillMetaToolBootstrap(host, deps) {
+    skillMetaToolRegistrationModule.register({ ...deps, host });
+}
+/**
+ * Resolve a supporting-file path inside a skill folder.
+ * Returns the absolute target, or null when the path escapes the skill dir
+ * or targets SKILL.md itself (SKILL.md must go through the validated
+ * content path, never the raw supporting-file write).
+ */
+export function resolveSupportingFilePath(skillDir, filePath) {
+    const target = path.resolve(skillDir, filePath);
+    const root = path.resolve(skillDir);
+    if (target !== root && !target.startsWith(root + path.sep))
+        return null;
+    if (path.basename(target).toLowerCase() === "skill.md")
+        return null;
+    return target;
+}
+function configureSkillMetaToolBootstrapInternal(host, deps) {
+    const pathService = deps.pathService;
+    // ─── Skill meta-tool (CC SkillTool parity: single tool) ──
+    // Single global store + per-project manifest: resolution is delegated to
+    // skill-resolver, evaluated against the CURRENT active project on each call.
+    deps.toolCatalog.addTool(createSkillMetaTool({
+        listSkills: () => {
+            const skills = resolveActiveSkills(host.getActiveProjectRoot()).map((s) => ({
+                name: s.name,
+                description: s.description,
+                source: s.enabledScope,
+                filePath: s.filePath,
+                baseDir: s.baseDir,
+            }));
+            skills.push(...host.getPluginSkills());
+            return skills;
+        },
+        listSkillsFull: async (category) => {
+            const skills = [];
+            const categories = new Set();
+            // Group by enablement scope ("global"/"project"); single store, deduped.
+            for (const s of resolveSkills(host.getActiveProjectRoot())) {
+                const cat = s.enabledScope;
+                if (category && cat !== category)
+                    continue;
+                categories.add(cat);
+                skills.push({
+                    name: s.name,
+                    description: s.description ?? `Skill (${cat})`,
+                    category: cat,
+                    scope: s.enabledScope,
+                    version: s.version,
+                });
+            }
+            for (const ps of host.getPluginSkills()) {
+                if (category && ps.source !== category)
+                    continue;
+                categories.add(ps.source ?? "plugin");
+                skills.push({ name: ps.name, description: `Plugin skill (${ps.source})`, category: ps.source, scope: "plugin" });
+            }
+            return { skills, categories: [...categories] };
+        },
+        readSkillContent: async (name) => {
+            const resolved = resolveSkillPath(name);
+            if (!resolved)
+                return null;
+            try {
+                return await fs.promises.readFile(resolved.filePath, "utf8");
+            }
+            catch {
+                return null;
+            }
+        },
+        viewSkill: async (name, filePath) => {
+            const resolved = resolveSkillPath(name);
+            if (!resolved)
+                return null;
+            const target = filePath
+                ? resolveSupportingFilePath(resolved.baseDir, filePath)
+                : resolved.filePath;
+            if (!target)
+                return null;
+            try {
+                const content = await fs.promises.readFile(target, "utf8");
+                return { name, content };
+            }
+            catch {
+                return null;
+            }
+        },
+        executeSkillSubturn: async (skillName, skillContent, userArgs, signal) => {
+            return executeSkillSubturn({
+                host,
+                toolCatalog: deps.toolCatalog,
+                skillName,
+                skillContent,
+                userArgs,
+                signal,
+            });
+        },
+        manageSkill: async (params) => {
+            // Single global store; new skills are project-scoped via the manifest
+            // (enabled only in the originating project) until promoted.
+            const projectRoot = host.getActiveProjectRoot();
+            const baseDir = pathService.getUserSkillsDir();
+            const skillDir = path.join(baseDir, params.name);
+            const skillMd = path.join(skillDir, "SKILL.md");
+            const agentHome = pathService.getOwnerProfileDir();
+            switch (params.action) {
+                case "create": {
+                    // Validate frontmatter before persisting
+                    const content = params.content ?? "";
+                    const fixed = autoFixFrontmatter(content, params.name, `Skill: ${params.name}`);
+                    const finalContent = fixed ?? content;
+                    const validation = validateSkillContent(finalContent, params.name);
+                    if (!validation.valid) {
+                        return { success: false, message: `Skill validation failed: ${validation.errors.join("; ")}` };
+                    }
+                    // Check pinned protection (can't overwrite pinned skill)
+                    const store = loadLifecycleStore(agentHome);
+                    if (store.records[params.name]?.pinned && fs.existsSync(skillMd)) {
+                        return { success: false, message: `Skill "${params.name}" is pinned. Unpin it first.` };
+                    }
+                    await fs.promises.mkdir(skillDir, { recursive: true });
+                    await fs.promises.writeFile(skillMd, finalContent, "utf8");
+                    // Surface the new skill to the gateway/UI (UI event only — the gateway
+                    // does not inject skills into the prompt; the model reaches skills via
+                    // the skill meta-tool, which resolves the single store + manifests).
+                    host.sendNotification("turn.skill_instruction", {
+                        turnId: `skill-create-${Date.now()}`,
+                        instruction: { name: params.name, category: params.category ?? "learned", content: finalContent, scope: "project" },
+                    });
+                    invalidateSkillRecallCache();
+                    // Update lifecycle store (created → project-scoped by default)
+                    ensureRecord(store, params.name, "created");
+                    saveLifecycleStore(agentHome, store);
+                    // Mark project-scoped + enable in the originating project (active here,
+                    // not globally) until promoted.
+                    markProjectScoped(params.name);
+                    if (projectRoot)
+                        enableSkill(projectRoot, params.name);
+                    // Write to local memory for cross-project semantic recall (best-effort)
+                    const memorySink = host.getMemoryLearningSink();
+                    const memoryUserId = host.getMemoryUserId();
+                    if (memorySink && memoryUserId) {
+                        const summary = finalContent.split("\n").slice(0, 3).join(" ").slice(0, 200);
+                        const projectName = projectRoot ? path.basename(projectRoot) : "unknown";
+                        memorySink.ingestExtracted([{ text: `Learned skill "${params.name}" in project "${projectName}": ${summary}`, category: "skill-learning" }], memoryUserId).catch(() => { }); // non-fatal
+                    }
+                    // Optional supporting file (scripts/references) alongside SKILL.md.
+                    if (params.filePath && params.fileContent !== undefined) {
+                        const target = resolveSupportingFilePath(skillDir, params.filePath);
+                        if (!target) {
+                            return { success: false, message: `Invalid supporting file path "${params.filePath}" (must stay inside the skill folder; SKILL.md goes through 'content').` };
+                        }
+                        await fs.promises.mkdir(path.dirname(target), { recursive: true });
+                        await fs.promises.writeFile(target, params.fileContent, "utf8");
+                    }
+                    const promoteHint = projectRoot
+                        ? ` (project-scoped). To make it available across all projects, use: skill promote name:"${params.name}"`
+                        : "";
+                    return { success: true, message: `Skill "${params.name}" created${promoteHint}`, path: skillDir };
+                }
+                case "edit": {
+                    // Check pinned protection
+                    const editStore = loadLifecycleStore(agentHome);
+                    if (editStore.records[params.name]?.pinned) {
+                        return { success: false, message: `Skill "${params.name}" is pinned. Unpin it first.` };
+                    }
+                    // Supporting-file-only edit: write the file, leave SKILL.md untouched.
+                    if (params.filePath && params.fileContent !== undefined && params.content === undefined) {
+                        const target = resolveSupportingFilePath(skillDir, params.filePath);
+                        if (!target) {
+                            return { success: false, message: `Invalid supporting file path "${params.filePath}" (must stay inside the skill folder; SKILL.md goes through 'content').` };
+                        }
+                        await fs.promises.mkdir(path.dirname(target), { recursive: true });
+                        await fs.promises.writeFile(target, params.fileContent, "utf8");
+                        recordPatch(editStore, params.name);
+                        saveLifecycleStore(agentHome, editStore);
+                        return { success: true, message: `Skill "${params.name}" supporting file "${params.filePath}" written`, path: target };
+                    }
+                    if (params.content === undefined) {
+                        return { success: false, message: "edit requires 'content' (SKILL.md) or 'filePath'+'fileContent' (supporting file)." };
+                    }
+                    const editContent = params.content;
+                    const editFixed = autoFixFrontmatter(editContent, params.name);
+                    const editFinal = editFixed ?? editContent;
+                    await fs.promises.writeFile(skillMd, editFinal, "utf8");
+                    // Update lifecycle
+                    recordPatch(editStore, params.name);
+                    saveLifecycleStore(agentHome, editStore);
+                    // Notify gateway of updated content
+                    host.sendNotification("turn.skill_instruction", {
+                        turnId: `skill-edit-${Date.now()}`,
+                        instruction: { name: params.name, category: params.category ?? "learned", content: editFinal, scope: "project" },
+                    });
+                    return { success: true, message: `Skill "${params.name}" updated`, path: skillMd };
+                }
+                case "patch": {
+                    // Check pinned protection
+                    const patchStore = loadLifecycleStore(agentHome);
+                    if (patchStore.records[params.name]?.pinned) {
+                        return { success: false, message: `Skill "${params.name}" is pinned. Unpin it first.` };
+                    }
+                    const current = await fs.promises.readFile(skillMd, "utf8");
+                    if (!params.oldString || !current.includes(params.oldString)) {
+                        return { success: false, message: "oldString not found in SKILL.md" };
+                    }
+                    const patched = current.replace(params.oldString, params.newString ?? "");
+                    await fs.promises.writeFile(skillMd, patched, "utf8");
+                    // Update lifecycle
+                    recordPatch(patchStore, params.name);
+                    saveLifecycleStore(agentHome, patchStore);
+                    // Notify gateway of patched content
+                    host.sendNotification("turn.skill_instruction", {
+                        turnId: `skill-patch-${Date.now()}`,
+                        instruction: { name: params.name, category: params.category ?? "learned", content: patched, scope: "project" },
+                    });
+                    return { success: true, message: `Skill "${params.name}" patched`, path: skillMd };
+                }
+                case "delete": {
+                    // Check pinned protection
+                    const delStore = loadLifecycleStore(agentHome);
+                    if (delStore.records[params.name]?.pinned) {
+                        return { success: false, message: `Skill "${params.name}" is pinned. Unpin it first.` };
+                    }
+                    await fs.promises.rm(skillDir, { recursive: true, force: true });
+                    // Remove lifecycle record + clean manifests (project + scoped registry)
+                    removeRecord(delStore, params.name);
+                    saveLifecycleStore(agentHome, delStore);
+                    unmarkProjectScoped(params.name);
+                    if (projectRoot)
+                        disableSkill(projectRoot, params.name);
+                    // Notify gateway to remove from its cache
+                    host.sendNotification("turn.skill_instruction", {
+                        turnId: `skill-delete-${Date.now()}`,
+                        instruction: { name: params.name, category: params.category ?? "learned", action: "delete", scope: "project" },
+                    });
+                    invalidateSkillRecallCache();
+                    return { success: true, message: `Skill "${params.name}" deleted` };
+                }
+                default:
+                    return { success: false, message: `Unknown action: ${params.action}` };
+            }
+        },
+        promoteSkill: async (name) => {
+            // Promote = flip enablement scope to global. Files already live in the
+            // single store; nothing is copied. The project manifest entry becomes
+            // redundant and is removed.
+            const resolved = resolveSkillPath(name);
+            if (!resolved) {
+                return { success: false, message: `Skill "${name}" not found in skill store. Cannot promote.` };
+            }
+            const agentHome = pathService.getOwnerProfileDir();
+            const store = loadLifecycleStore(agentHome);
+            const rec = ensureRecord(store, name);
+            rec.source = "promoted";
+            saveLifecycleStore(agentHome, store);
+            unmarkProjectScoped(name); // global from now on
+            const projectRoot = host.getActiveProjectRoot();
+            if (projectRoot)
+                disableSkill(projectRoot, name);
+            // Emit turn.skill_instruction so the gateway updates its injection scope.
+            let content = "";
+            try {
+                content = await fs.promises.readFile(resolved.filePath, "utf8");
+            }
+            catch { /* best-effort */ }
+            host.sendNotification("turn.skill_instruction", {
+                turnId: `skill-promote-${Date.now()}`,
+                instruction: { name, category: "promoted", content, scope: "global" },
+            });
+            invalidateSkillRecallCache();
+            return {
+                success: true,
+                message: `Skill "${name}" promoted to global. It is now available across all projects.`,
+                path: resolved.baseDir,
+            };
+        },
+    }));
+}

package/dist/cli/skill-meta-tool-bootstrap.test.d.ts

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

package/dist/cli/skill-meta-tool-bootstrap.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { resolveSkillSubagentTypeForLifecycle } from "./skill-meta-tool-bootstrap.js";
+describe("skill meta tool community subturn scope", () => {
+    it("marks untrusted installed skills as community-skill subturns", () => {
+        expect(resolveSkillSubagentTypeForLifecycle("email-ops", {
+            name: "email-ops",
+            state: "active",
+            createdAt: "2026-06-01T00:00:00.000Z",
+            pinned: false,
+            useCount: 0,
+            source: "installed",
+            registrySourceTier: "community",
+        })).toBe("community-skill:email-ops");
+        expect(resolveSkillSubagentTypeForLifecycle("legacy-installed", {
+            name: "legacy-installed",
+            state: "active",
+            createdAt: "2026-06-01T00:00:00.000Z",
+            pinned: false,
+            useCount: 0,
+            source: "installed",
+        })).toBe("community-skill:legacy-installed");
+    });
+    it("keeps official and locally authored skills on the first-party skill path", () => {
+        expect(resolveSkillSubagentTypeForLifecycle("official-skill", {
+            name: "official-skill",
+            state: "active",
+            createdAt: "2026-06-01T00:00:00.000Z",
+            pinned: false,
+            useCount: 0,
+            source: "installed",
+            registrySourceTier: "official",
+        })).toBe("skill:official-skill");
+        expect(resolveSkillSubagentTypeForLifecycle("local-skill", {
+            name: "local-skill",
+            state: "active",
+            createdAt: "2026-06-01T00:00:00.000Z",
+            pinned: false,
+            useCount: 0,
+            source: "created",
+        })).toBe("skill:local-skill");
+    });
+});

package/dist/cli/skill-supporting-file.test.d.ts

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

package/dist/cli/skill-supporting-file.test.js

@@ -0,0 +1,97 @@
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { afterEach, describe, expect, it } from "vitest";
+import { configureSkillMetaToolBootstrap, resolveSupportingFilePath } from "./skill-meta-tool-bootstrap.js";
+const SKILL_DIR = path.resolve("/tmp/skills/my-skill");
+describe("resolveSupportingFilePath", () => {
+    it("resolves relative paths inside the skill folder", () => {
+        expect(resolveSupportingFilePath(SKILL_DIR, "scripts/run.py"))
+            .toBe(path.join(SKILL_DIR, "scripts", "run.py"));
+        expect(resolveSupportingFilePath(SKILL_DIR, "reference.md"))
+            .toBe(path.join(SKILL_DIR, "reference.md"));
+    });
+    it("rejects path traversal out of the skill folder", () => {
+        expect(resolveSupportingFilePath(SKILL_DIR, "../other-skill/SKILL.md")).toBeNull();
+        expect(resolveSupportingFilePath(SKILL_DIR, "../../etc/passwd")).toBeNull();
+        expect(resolveSupportingFilePath(SKILL_DIR, path.resolve("/tmp/outside.txt"))).toBeNull();
+    });
+    it("rejects SKILL.md itself — it must go through the validated content path", () => {
+        expect(resolveSupportingFilePath(SKILL_DIR, "SKILL.md")).toBeNull();
+        expect(resolveSupportingFilePath(SKILL_DIR, "skill.md")).toBeNull();
+        expect(resolveSupportingFilePath(SKILL_DIR, "nested/SKILL.md")).toBeNull();
+    });
+});
+describe("skill view supporting files", () => {
+    const originalHome = process.env.QLOGICAGENT_HOME;
+    const tempDirs = [];
+    afterEach(async () => {
+        if (originalHome === undefined) {
+            delete process.env.QLOGICAGENT_HOME;
+        }
+        else {
+            process.env.QLOGICAGENT_HOME = originalHome;
+        }
+        await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+    });
+    it("does not read a supporting file outside the skill folder", async () => {
+        const home = await fs.mkdtemp(path.join(os.tmpdir(), "qlogicagent-skill-view-"));
+        tempDirs.push(home);
+        process.env.QLOGICAGENT_HOME = home;
+        const skillsDir = path.join(home, "profiles", "oc_local", "skills");
+        const skillDir = path.join(skillsDir, "safe-skill");
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\ndescription: safe\n---\nbody", "utf8");
+        await fs.writeFile(path.join(skillsDir, "leak.txt"), "outside secret", "utf8");
+        let registered;
+        const catalog = {
+            addTool(tool) {
+                registered = tool;
+            },
+        };
+        const projectRoot = path.join(home, "project");
+        const pathService = {
+            getActiveProjectRoot: () => projectRoot,
+            setActiveWorkdir: () => { },
+            getActiveWorkdir: () => projectRoot,
+            resolveProjectDir: () => undefined,
+            resolveActiveOwnerUserId: () => "oc_local",
+            getUserAgentHome: () => home,
+            getOwnerProfileDir: () => path.join(home, "profiles", "oc_local"),
+            getProfileMemoryDir: () => path.join(home, "profiles", "oc_local", "memory"),
+            getUserSettingsPath: () => path.join(home, "profiles", "oc_local", "settings.json"),
+            getUserSkillsDir: () => skillsDir,
+            getUserPluginsDir: () => path.join(home, "profiles", "oc_local", "plugins"),
+            getUserMcpConfigPath: () => path.join(home, "profiles", "oc_local", "mcp.json"),
+            getUserPluginCacheDir: () => path.join(home, "profiles", "oc_local", "plugin-cache"),
+            getUserMarketplaceConfigPath: () => path.join(home, "profiles", "oc_local", "marketplace.json"),
+            getProjectAgentDir: () => path.join(projectRoot, ".qlogicagent"),
+            getProjectSettingsPath: () => path.join(projectRoot, ".qlogicagent", "settings.json"),
+            getProjectInstructionsPath: () => path.join(projectRoot, ".qlogicagent", "INSTRUCTIONS.md"),
+            getProjectPluginsDir: () => path.join(projectRoot, ".qlogicagent", "plugins"),
+            getProjectRulesDir: () => path.join(projectRoot, ".qlogicagent", "rules"),
+            getProjectSessionsRoot: () => path.join(projectRoot, ".qlogicagent", "sessions"),
+        };
+        configureSkillMetaToolBootstrap({
+            getActiveProjectRoot: () => projectRoot,
+            getPluginSkills: () => [],
+            getAgent: () => null,
+            getCurrentSessionId: () => "session",
+            getCurrentHooks: () => null,
+            sendNotification: () => { },
+            getMemoryLearningSink: () => null,
+            getMemoryUserId: () => "oc_local",
+        }, {
+            config: {},
+            pathService,
+            toolCatalog: catalog,
+        });
+        const result = await registered?.execute?.("call-1", {
+            action: "view",
+            name: "safe-skill",
+            filePath: "../leak.txt",
+        });
+        expect(result?.details).toMatchObject({ action: "view", error: "not_found" });
+        expect(result?.content[0]?.text).not.toContain("outside secret");
+    });
+});

package/dist/cli/skills-query-service.d.ts

@@ -0,0 +1,29 @@
+export interface SkillListEntry {
+    id: string;
+    name: string;
+    path: string;
+    /** Effective in this project: globally-scoped, or enabled via the project manifest. */
+    active: boolean;
+    /** Enablement scope (= lifecycle enabledScope). "global" is active everywhere. */
+    scope: "project" | "global";
+    category: "automation";
+    displayName: {
+        key: string;
+        fallback: string;
+    };
+    displayDescription: {
+        key: string;
+        fallback: string;
+    };
+    fallbackName: string;
+    fallbackDescription: string;
+    systemGenerated: boolean;
+    version?: string;
+    description?: string;
+}
+/**
+ * List every skill in the single global store, annotated with its enablement
+ * scope and whether it is active in the given project. Name-collisions cannot
+ * occur (one directory per name in the store), so each skill appears once.
+ */
+export declare function listSkillsForProject(projectRoot?: string): SkillListEntry[];

package/dist/cli/skills-query-service.js

@@ -0,0 +1,38 @@
+import { resolveSkills } from "../runtime/infra/skill-resolver.js";
+/**
+ * List every skill in the single global store, annotated with its enablement
+ * scope and whether it is active in the given project. Name-collisions cannot
+ * occur (one directory per name in the store), so each skill appears once.
+ */
+export function listSkillsForProject(projectRoot) {
+    return resolveSkills(projectRoot).map(toListEntry);
+}
+function toListEntry(s) {
+    return {
+        id: `${s.enabledScope}:${s.name}`,
+        name: s.name,
+        path: s.baseDir,
+        active: s.active,
+        scope: s.enabledScope,
+        category: "automation",
+        displayName: skillDisplayName(s.name),
+        displayDescription: skillDisplayDescription(s.name, s.description),
+        fallbackName: s.name,
+        fallbackDescription: s.description ?? "",
+        systemGenerated: s.systemGenerated,
+        version: s.version,
+        description: s.description,
+    };
+}
+function skillDisplayName(name) {
+    return {
+        key: `capability.skill.${name}.name`,
+        fallback: name,
+    };
+}
+function skillDisplayDescription(name, description) {
+    return {
+        key: `capability.skill.${name}.description`,
+        fallback: description ?? "",
+    };
+}

package/dist/cli/stdio-acp-protocol-coordinator.d.ts

@@ -0,0 +1,18 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import { AcpServer, type AcpRequestHandler } from "../transport/acp-server.js";
+import type { Transport } from "./transport.js";
+export declare class StdioAcpProtocolCoordinator {
+    private server;
+    get active(): boolean;
+    init(transport: Transport, handler: AcpRequestHandler, options: {
+        verbose: boolean;
+    }): void;
+    getServer(): AcpServer | null;
+    dispatchMessage(message: unknown): void;
+    hasSession(sessionId: string): boolean;
+    getPermissionSession(sessionId: string): {
+        sessionId: string;
+        requestPermission: AcpServer["requestPermission"];
+    } | undefined;
+    emitUpdate<M extends NotificationMethod>(sessionId: string, method: M, params: NotificationMethodMap[M]): boolean;
+}

package/dist/cli/stdio-acp-protocol-coordinator.js

@@ -0,0 +1,33 @@
+import { emitAcpUpdate } from "../transport/acp-event-emitter.js";
+import { AcpServer } from "../transport/acp-server.js";
+export class StdioAcpProtocolCoordinator {
+    server = null;
+    get active() {
+        return this.server !== null;
+    }
+    init(transport, handler, options) {
+        this.server = new AcpServer(transport, handler, options);
+    }
+    getServer() {
+        return this.server;
+    }
+    dispatchMessage(message) {
+        this.server?.dispatchMessage(message);
+    }
+    hasSession(sessionId) {
+        return Boolean(this.server?.hasSession(sessionId));
+    }
+    getPermissionSession(sessionId) {
+        if (!this.server?.hasSession(sessionId))
+            return undefined;
+        return {
+            sessionId,
+            requestPermission: (params) => this.server.requestPermission(params),
+        };
+    }
+    emitUpdate(sessionId, method, params) {
+        if (!this.server)
+            return false;
+        return emitAcpUpdate(this.server, sessionId, method, params);
+    }
+}

package/dist/cli/stdio-acp-request-host.d.ts

@@ -0,0 +1,28 @@
+import type { CliAcpRequestHandlerHost } from "./cli-acp-request-handler.js";
+/**
+ * Everything the ACP request handlers — INCLUDING the shared turn pipeline
+ * (`runTurnPipeline`, which `session/prompt` invokes with this adapter as
+ * `this`) — read off the host. The turn pipeline's host contract is implicit
+ * (`this: any`), so members it touches must be forwarded here explicitly;
+ * see TURN_PIPELINE_HOST_MEMBERS for the regression-tested list.
+ */
+export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTurn" | "acpSessionMeta" | "currentHooks" | "currentSessionId" | "currentTurnId" | "memoryPrefetchState" | "permissionChecker" | "sessionHistory" | "sessionLlmConfig" | "sessionState" | "sessionTaskDomain" | "cancelIdleDreamTimer" | "disposeSessionRuntime" | "enableIdleDream" | "ensureDefaultProject" | "ensureModelRegistryHydrated" | "getActiveProjectRoot" | "log" | "sendNotification" | "setActiveWorkdir"> & {
+    currentModel: string | undefined;
+    lastAssistantMessageForExtract: string | undefined;
+    lastUserMessageForAutoExtract: string | undefined;
+    mcpReady: Promise<void>;
+    memdir: unknown;
+    pendingAskUser: unknown;
+    petRuntime: unknown;
+    projectMemoryStoreFactory: unknown;
+    toolCatalog: unknown;
+    configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
+    drainPendingTaskNotifications(): string[];
+    resolveAgent(config: unknown): unknown;
+    resolveClientForPurpose(purpose: unknown): unknown;
+    sendResponse(id: string | number, result?: unknown, error?: unknown): void;
+};
+/** Host members the shared turn pipeline reads/writes — keep in sync with
+ * `grep -oE "this\.[a-zA-Z]+" src/cli/handlers/turn-handler.ts | sort -u`. */
+export declare const TURN_PIPELINE_HOST_MEMBERS: readonly ["activeTurn", "configureTurnMedia", "currentHooks", "currentModel", "currentTurnId", "drainPendingTaskNotifications", "getActiveProjectRoot", "lastAssistantMessageForExtract", "lastUserMessageForAutoExtract", "log", "mcpReady", "memdir", "pendingAskUser", "permissionChecker", "petRuntime", "projectMemoryStoreFactory", "resolveAgent", "resolveClientForPurpose", "sendNotification", "sendResponse", "sessionHistory", "sessionState", "sessionTaskDomain", "setActiveWorkdir", "toolCatalog"];
+export declare function createStdioAcpRequestHandlerHost(host: StdioAcpRequestHostSource): CliAcpRequestHandlerHost;