qlogicagent 2.13.5 → 2.13.7

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

@@ -1,295 +0,0 @@
-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

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

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

@@ -1,42 +0,0 @@
-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

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

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

@@ -1,97 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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;