qlogicagent 2.13.4 → 2.13.5

package/dist/cli/turn-skill-autopersist.d.ts

@@ -0,0 +1,47 @@
+import { type CommunityPublishSkillInput, type CommunityPublishSkillResult } from "../runtime/community/community-consent-client.js";
+import { type CommunityTelemetryRecorder } from "../runtime/community/community-telemetry-recorder.js";
+export interface TurnSkillAutoPersistHost {
+    log(message: string): void;
+}
+export interface CommunitySkillPublisher {
+    publishSkill(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
+}
+export type AutoPersistResult = {
+    status: "ignored";
+} | {
+    status: "exists";
+    skillPath: string;
+} | {
+    status: "created";
+    skillPath: string;
+} | {
+    status: "blocked";
+    skillPath: string;
+    reason: string;
+} | {
+    status: "skipped";
+    skillPath: string;
+    reason: string;
+};
+export type CommunityPublishAuditDecision = "published" | "blocked" | "skipped";
+export interface CommunityPublishAuditEntry {
+    eventTurnId: string;
+    skillName: string;
+    decision: CommunityPublishAuditDecision;
+    reason: string;
+    resourceId?: string;
+    createdAt: string;
+}
+export declare const COMMUNITY_PUBLISH_AUDIT_FILE = "community-publish-audit.jsonl";
+export declare function maybeAutoPersistSkillInstruction(params: {
+    instruction: unknown;
+    eventTurnId: string;
+    projectRoot: string;
+    host: TurnSkillAutoPersistHost;
+    communityPublisher?: CommunitySkillPublisher | null;
+    communityTelemetryRecorder?: CommunityTelemetryRecorder | null;
+}): Promise<AutoPersistResult>;
+export declare function createDefaultCommunitySkillPublisher(): CommunitySkillPublisher | null;
+export declare function listCommunityPublishAuditEntries(input?: {
+    limit?: number;
+}): CommunityPublishAuditEntry[];

package/dist/cli/turn-skill-autopersist.js

@@ -0,0 +1,262 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { gzipSync } from "node:zlib";
+import { getDefaultPathService } from "../runtime/infra/default-path-service.js";
+import { enableSkill, markProjectScoped } from "../runtime/infra/project-skill-manifest.js";
+import { createDefaultCommunityConsentClient, normalizeCommunityConsent, } from "../runtime/community/community-consent-client.js";
+import { createDefaultCommunityTelemetryRecorder, recordCommunityTelemetryBestEffort, } from "../runtime/community/community-telemetry-recorder.js";
+import { detectCommunityPublishSensitiveContent } from "../runtime/community/community-desensitization.js";
+import { invalidateSkillRecallCache } from "../runtime/hooks/skill-recall-hooks.js";
+import { ensureRecord, saveLifecycleStore, loadLifecycleStore } from "../skills/skill-system/skill-lifecycle.js";
+import { generateSkillContent, validateSkillContent } from "../skills/skill-system/skill-validation.js";
+export const COMMUNITY_PUBLISH_AUDIT_FILE = "community-publish-audit.jsonl";
+const MIN_SHAREABLE_DESCRIPTION_LENGTH = 40;
+export async function maybeAutoPersistSkillInstruction(params) {
+    const instruction = params.instruction;
+    if (!isSkillCreateInstruction(instruction))
+        return { status: "ignored" };
+    // Single global store; the learned skill is enabled only in the originating project.
+    const skillsDir = getDefaultPathService().getUserSkillsDir();
+    const skillDir = path.join(skillsDir, instruction.suggestedName);
+    const skillMd = path.join(skillDir, "SKILL.md");
+    if (fs.existsSync(skillMd))
+        return { status: "exists", skillPath: skillMd };
+    const content = generateSkillContent({
+        name: instruction.suggestedName,
+        description: instruction.description,
+        tools: instruction.tools,
+        body: `# ${instruction.suggestedName}\n\nAuto-learned multi-step workflow using: ${instruction.tools.join(", ")}.\n`,
+        version: "1.0.0",
+        category: "learned",
+    });
+    const validation = validateSkillContent(content, instruction.suggestedName);
+    if (!validation.valid) {
+        params.host.log(`[skill-auto-persist] Validation failed for "${instruction.suggestedName}": ${validation.errors.join(", ")}`);
+        return { status: "skipped", skillPath: skillMd, reason: "validation failed" };
+    }
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(skillMd, content, "utf8");
+    invalidateSkillRecallCache();
+    const agentHome = getDefaultPathService().getOwnerProfileDir();
+    const store = loadLifecycleStore(agentHome);
+    ensureRecord(store, instruction.suggestedName, "learned");
+    saveLifecycleStore(agentHome, store);
+    // Mark project-scoped + enable only in the originating project — keeps the
+    // learned skill out of other projects until promoted.
+    markProjectScoped(instruction.suggestedName);
+    enableSkill(params.projectRoot, instruction.suggestedName);
+    params.host.log(`[skill-auto-persist] Created skill "${instruction.suggestedName}" from turn ${params.eventTurnId}`);
+    const publishDecision = assessCommunityPublishCandidate(instruction, content);
+    if (publishDecision.decision !== "eligible") {
+        if (publishDecision.decision === "blocked") {
+            recordCommunityTelemetryBestEffort(params.communityTelemetryRecorder ?? createDefaultCommunityTelemetryRecorder(), {
+                event: "community.desensitization.hit",
+                metadata: {
+                    surface: "skill-auto-persist",
+                    action: "publish-blocked",
+                    ruleId: toTelemetryRuleId(publishDecision.reason),
+                },
+            });
+        }
+        writeCommunityPublishAudit({
+            eventTurnId: params.eventTurnId,
+            skillName: instruction.suggestedName,
+            decision: publishDecision.decision,
+            reason: publishDecision.reason,
+        });
+        params.host.log(`[skill-auto-persist] Community publish ${publishDecision.decision} for "${instruction.suggestedName}": ${publishDecision.reason}`);
+        return {
+            status: publishDecision.decision,
+            skillPath: skillMd,
+            reason: publishDecision.reason,
+        };
+    }
+    const publisher = params.communityPublisher ?? createDefaultCommunitySkillPublisher();
+    if (!publisher) {
+        writeCommunityPublishAudit({
+            eventTurnId: params.eventTurnId,
+            skillName: instruction.suggestedName,
+            decision: "skipped",
+            reason: "community unavailable",
+        });
+        params.host.log(`[skill-auto-persist] Community publish skipped for "${instruction.suggestedName}": community unavailable`);
+        return { status: "skipped", skillPath: skillMd, reason: "community unavailable" };
+    }
+    const payload = buildCommunityPublishSkillInput(instruction, content);
+    try {
+        await publisher.publishSkill(payload);
+        writeCommunityPublishAudit({
+            eventTurnId: params.eventTurnId,
+            skillName: instruction.suggestedName,
+            decision: "published",
+            reason: "eligible",
+            resourceId: payload.id,
+        });
+        params.host.log(`[skill-auto-persist] Published skill "${instruction.suggestedName}" to community registry`);
+        return { status: "created", skillPath: skillMd };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        writeCommunityPublishAudit({
+            eventTurnId: params.eventTurnId,
+            skillName: instruction.suggestedName,
+            decision: "skipped",
+            reason: message,
+            resourceId: payload.id,
+        });
+        params.host.log(`[skill-auto-persist] Community publish skipped for "${instruction.suggestedName}": ${message}`);
+        return { status: "skipped", skillPath: skillMd, reason: message };
+    }
+}
+export function createDefaultCommunitySkillPublisher() {
+    const client = createDefaultCommunityConsentClient();
+    if (!client)
+        return null;
+    return {
+        async publishSkill(input) {
+            const consent = readLocalCommunityConsent();
+            if (!consent.enabled || !consent.methodSharingEnabled || !consent.remoteSynced) {
+                throw new Error("Community participation consent is required before publishing shared skills.");
+            }
+            return client.publishSkill(input);
+        },
+    };
+}
+export function listCommunityPublishAuditEntries(input = {}) {
+    const limit = normalizeAuditLimit(input.limit);
+    if (limit === 0)
+        return [];
+    const auditPath = path.join(getDefaultPathService().getOwnerProfileDir(), COMMUNITY_PUBLISH_AUDIT_FILE);
+    let content;
+    try {
+        content = fs.readFileSync(auditPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    return content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => {
+        try {
+            return parseCommunityPublishAuditEntry(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => entry !== null)
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))
+        .slice(0, limit);
+}
+function assessCommunityPublishCandidate(instruction, content) {
+    const uniqueTools = normalizedUnique(instruction.tools);
+    if (uniqueTools.length < 2 || instruction.description.trim().length < MIN_SHAREABLE_DESCRIPTION_LENGTH) {
+        return { decision: "skipped", reason: "not worth sharing" };
+    }
+    const sensitiveReason = detectCommunityPublishSensitiveContent(content);
+    if (sensitiveReason)
+        return { decision: "blocked", reason: sensitiveReason.reason };
+    return { decision: "eligible", reason: "eligible" };
+}
+function buildCommunityPublishSkillInput(instruction, content) {
+    const tools = normalizedUnique(instruction.tools);
+    const id = toRegistrySkillId(instruction.suggestedName);
+    const summary = instruction.description.trim().slice(0, 240);
+    return {
+        id,
+        title: instruction.suggestedName,
+        summary,
+        visibility: "public",
+        tags: normalizedUnique(["learned", ...tools]).slice(0, 8),
+        manifest: {
+            schema_version: 15,
+            kind: "inert",
+            name: id,
+            summary,
+            description: instruction.description.trim(),
+            triggers: tools,
+            entry: "SKILL.md",
+            tags: normalizedUnique(["learned", ...tools]).slice(0, 8),
+        },
+        version: "1.0.0",
+        packageGzipBase64: gzipSync(Buffer.from(content, "utf8")).toString("base64"),
+    };
+}
+function toRegistrySkillId(name) {
+    const id = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/-+$/g, "");
+    return id.length >= 3 ? id : `skill-${id}`.replace(/-+$/g, "");
+}
+function normalizedUnique(items) {
+    return [...new Set(items.map(item => item.trim().toLowerCase()).filter(Boolean))];
+}
+function toTelemetryRuleId(reason) {
+    return reason
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || "desensitization-hit";
+}
+function readLocalCommunityConsent() {
+    try {
+        const settings = JSON.parse(fs.readFileSync(getDefaultPathService().getUserSettingsPath(), "utf8"));
+        const consent = settings.communityConsent;
+        return normalizeCommunityConsent(settings.communityConsent, consent?.remoteSynced === true);
+    }
+    catch {
+        return normalizeCommunityConsent(null, false);
+    }
+}
+function writeCommunityPublishAudit(entry) {
+    const profileDir = getDefaultPathService().getOwnerProfileDir();
+    fs.mkdirSync(profileDir, { recursive: true });
+    fs.appendFileSync(path.join(profileDir, COMMUNITY_PUBLISH_AUDIT_FILE), `${JSON.stringify({ ...entry, createdAt: new Date().toISOString() })}\n`, "utf8");
+}
+function normalizeAuditLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 50;
+    return Math.max(0, Math.min(200, Math.trunc(value)));
+}
+function parseCommunityPublishAuditEntry(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const entry = value;
+    if (typeof entry.eventTurnId !== "string" || !entry.eventTurnId.trim())
+        return null;
+    if (typeof entry.skillName !== "string" || !entry.skillName.trim())
+        return null;
+    if (entry.decision !== "published" && entry.decision !== "blocked" && entry.decision !== "skipped")
+        return null;
+    if (typeof entry.reason !== "string" || !entry.reason.trim())
+        return null;
+    if (typeof entry.createdAt !== "string" || Number.isNaN(Date.parse(entry.createdAt)))
+        return null;
+    const parsed = {
+        eventTurnId: entry.eventTurnId,
+        skillName: entry.skillName,
+        decision: entry.decision,
+        reason: entry.reason,
+        createdAt: entry.createdAt,
+    };
+    if (typeof entry.resourceId === "string" && entry.resourceId.trim())
+        parsed.resourceId = entry.resourceId;
+    return parsed;
+}
+function isSkillCreateInstruction(instruction) {
+    if (!instruction || typeof instruction !== "object")
+        return false;
+    const candidate = instruction;
+    return (candidate.type === "skill.create" &&
+        typeof candidate.suggestedName === "string" &&
+        typeof candidate.description === "string" &&
+        Array.isArray(candidate.tools) &&
+        candidate.tools.every(tool => typeof tool === "string"));
+}

package/dist/cli/turn-skill-autopersist.test.d.ts

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

package/dist/cli/turn-skill-autopersist.test.js

@@ -0,0 +1,222 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { gunzipSync } from "node:zlib";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getOwnerProfileDir, getUserSkillsDir } from "../runtime/infra/agent-paths.js";
+import { readEnabledSkills, readProjectScopedSkills } from "../runtime/infra/project-skill-manifest.js";
+import { maybeAutoPersistSkillInstruction } from "./turn-skill-autopersist.js";
+function tempDir(prefix) {
+    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+function readAudit(home) {
+    const auditPath = path.join(getOwnerProfileDir("user/alice"), "community-publish-audit.jsonl");
+    if (!fs.existsSync(auditPath))
+        return [];
+    return fs.readFileSync(auditPath, "utf8")
+        .trim()
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map(line => JSON.parse(line));
+}
+function sharedResource(id) {
+    return {
+        id,
+        type: "skill",
+        title: id,
+        summary: "Reusable learned skill",
+        visibility: "public",
+        latestVersion: "1.0.0",
+        withdrawn: false,
+        withdrawnAt: null,
+    };
+}
+describe("turn skill auto persist community publishing", () => {
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.unstubAllGlobals();
+    });
+    it("publishes an eligible learned skill through the community publisher after local persistence", async () => {
+        const home = tempDir("qlogic-community-home-");
+        const workspace = tempDir("qlogic-community-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const published = [];
+        const publisher = {
+            async publishSkill(input) {
+                published.push(input);
+                return { resource: sharedResource(input.id) };
+            },
+        };
+        const logs = [];
+        const result = await maybeAutoPersistSkillInstruction({
+            instruction: {
+                type: "skill.create",
+                suggestedName: "email-ops",
+                description: "Reusable email triage workflow that summarizes incoming requests, drafts follow-ups, and files the outcome.",
+                tools: ["mail", "calendar"],
+            },
+            eventTurnId: "turn-1",
+            projectRoot: workspace,
+            host: { log: message => logs.push(message) },
+            communityPublisher: publisher,
+        });
+        expect(result.status).toBe("created");
+        // Single global store + project-scoped + enabled only in the originating project.
+        expect(fs.existsSync(path.join(getUserSkillsDir(), "email-ops", "SKILL.md"))).toBe(true);
+        expect(fs.existsSync(path.join(workspace, ".qlogicagent", "skills", "email-ops", "SKILL.md"))).toBe(false);
+        expect(readProjectScopedSkills().has("email-ops")).toBe(true);
+        expect(readEnabledSkills(workspace).has("email-ops")).toBe(true);
+        expect(published).toHaveLength(1);
+        const payload = published[0];
+        expect(payload).toMatchObject({
+            id: "email-ops",
+            title: "email-ops",
+            summary: "Reusable email triage workflow that summarizes incoming requests, drafts follow-ups, and files the outcome.",
+            visibility: "public",
+            version: "1.0.0",
+            tags: ["learned", "mail", "calendar"],
+            manifest: {
+                schema_version: 15,
+                kind: "inert",
+                name: "email-ops",
+                entry: "SKILL.md",
+                triggers: ["mail", "calendar"],
+            },
+        });
+        const packageBytes = Buffer.from(String(payload?.packageGzipBase64), "base64");
+        expect([...packageBytes.slice(0, 2)]).toEqual([0x1f, 0x8b]);
+        expect(gunzipSync(packageBytes).toString("utf8")).toContain("Auto-learned multi-step workflow");
+        expect(readAudit(home).at(-1)).toMatchObject({
+            skillName: "email-ops",
+            decision: "published",
+            reason: "eligible",
+        });
+    });
+    it("blocks community publishing when generated skill content contains private data", async () => {
+        const home = tempDir("qlogic-community-home-");
+        const workspace = tempDir("qlogic-community-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const publishSkill = vi.fn(async (input) => ({ resource: sharedResource(input.id) }));
+        const publisher = {
+            publishSkill,
+        };
+        const result = await maybeAutoPersistSkillInstruction({
+            instruction: {
+                type: "skill.create",
+                suggestedName: "email-ops",
+                description: "Reusable email triage workflow for alice@example.com with follow-up drafting and filing.",
+                tools: ["mail", "calendar"],
+            },
+            eventTurnId: "turn-2",
+            projectRoot: workspace,
+            host: { log: () => undefined },
+            communityPublisher: publisher,
+        });
+        expect(result.status).toBe("blocked");
+        expect(fs.existsSync(path.join(getUserSkillsDir(), "email-ops", "SKILL.md"))).toBe(true);
+        expect(publishSkill).not.toHaveBeenCalled();
+        expect(readAudit(home).at(-1)).toMatchObject({
+            skillName: "email-ops",
+            decision: "blocked",
+            reason: "sensitive email",
+        });
+    });
+    it("records desensitization telemetry when private data blocks community publishing", async () => {
+        const home = tempDir("qlogic-community-home-");
+        const workspace = tempDir("qlogic-community-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const publishSkill = vi.fn(async (input) => ({ resource: sharedResource(input.id) }));
+        const telemetry = [];
+        await maybeAutoPersistSkillInstruction({
+            instruction: {
+                type: "skill.create",
+                suggestedName: "email-ops",
+                description: "Reusable email triage workflow for alice@example.com with follow-up drafting and filing.",
+                tools: ["mail", "calendar"],
+            },
+            eventTurnId: "turn-telemetry",
+            projectRoot: workspace,
+            host: { log: () => undefined },
+            communityPublisher: { publishSkill },
+            communityTelemetryRecorder: {
+                async recordTelemetry(input) {
+                    telemetry.push(input);
+                },
+            },
+        });
+        expect(publishSkill).not.toHaveBeenCalled();
+        expect(telemetry).toEqual([{
+                event: "community.desensitization.hit",
+                metadata: {
+                    surface: "skill-auto-persist",
+                    action: "publish-blocked",
+                    ruleId: "sensitive-email",
+                },
+            }]);
+        expect(JSON.stringify(telemetry)).not.toContain("alice@example.com");
+        expect(JSON.stringify(telemetry)).not.toContain("Reusable email triage workflow");
+    });
+    it("does not publish low-value single-tool learned skills", async () => {
+        const home = tempDir("qlogic-community-home-");
+        const workspace = tempDir("qlogic-community-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const publishSkill = vi.fn(async (input) => ({ resource: sharedResource(input.id) }));
+        const publisher = {
+            publishSkill,
+        };
+        const result = await maybeAutoPersistSkillInstruction({
+            instruction: {
+                type: "skill.create",
+                suggestedName: "clip",
+                description: "Copy text.",
+                tools: ["clipboard"],
+            },
+            eventTurnId: "turn-3",
+            projectRoot: workspace,
+            host: { log: () => undefined },
+            communityPublisher: publisher,
+        });
+        expect(result.status).toBe("skipped");
+        expect(publishSkill).not.toHaveBeenCalled();
+        expect(readAudit(home).at(-1)).toMatchObject({
+            skillName: "clip",
+            decision: "skipped",
+            reason: "not worth sharing",
+        });
+    });
+    it("uses the default publisher gate and does not touch the network when local consent is off", async () => {
+        const home = tempDir("qlogic-community-home-");
+        const workspace = tempDir("qlogic-community-workspace-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        vi.stubEnv("QLOGIC_LLMROUTER_ACCESS_TOKEN", "jwt-123");
+        vi.stubEnv("QLOGIC_LLMROUTER_BASE_URL", "https://hub.example");
+        const fetchFn = vi.fn(async () => Response.json({ ok: true }));
+        vi.stubGlobal("fetch", fetchFn);
+        const result = await maybeAutoPersistSkillInstruction({
+            instruction: {
+                type: "skill.create",
+                suggestedName: "email-ops",
+                description: "Reusable email triage workflow that summarizes incoming requests, drafts follow-ups, and files the outcome.",
+                tools: ["mail", "calendar"],
+            },
+            eventTurnId: "turn-4",
+            projectRoot: workspace,
+            host: { log: () => undefined },
+        });
+        expect(result).toMatchObject({
+            status: "skipped",
+            reason: "Community participation consent is required before publishing shared skills.",
+        });
+        expect(fetchFn).not.toHaveBeenCalled();
+        expect(readAudit(home).at(-1)).toMatchObject({
+            skillName: "email-ops",
+            decision: "skipped",
+            reason: "Community participation consent is required before publishing shared skills.",
+        });
+    });
+});

package/dist/cli/turn-suggestion-generator.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "../agent/types.js";
+import type { NotificationMethodMap } from "../protocol/notifications.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface TurnSuggestionClient {
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export interface TurnSuggestionGeneratorDeps {
+    turnId: string;
+    messages: ChatMessage[];
+    client: TurnSuggestionClient | null;
+    sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
+}
+export declare function generateTurnSuggestions({ turnId, messages, client, sendNotification, }: TurnSuggestionGeneratorDeps): Promise<void>;

package/dist/cli/turn-suggestion-generator.js

@@ -0,0 +1,34 @@
+const SUGGESTION_PROMPT = "[SUGGESTION MODE]\n" +
+    "Based on the conversation, suggest 1-3 short follow-up actions the user might naturally do next.\n" +
+    "Be specific: \"run the tests\" beats \"continue\".\n" +
+    "Stay silent if the next step isn't obvious.\n" +
+    "Reply with ONLY a JSON array: [{\"text\":\"short suggestion\"}]. No explanation.";
+export async function generateTurnSuggestions({ turnId, messages, client, sendNotification, }) {
+    const assistantCount = messages.filter(m => m.role === "assistant").length;
+    if (assistantCount < 1 || !client)
+        return;
+    const suggestionMessages = [
+        ...messages.slice(-6),
+        { role: "user", content: SUGGESTION_PROMPT },
+    ];
+    try {
+        let result = "";
+        for await (const chunk of client.transport.stream({ model: client.model, messages: suggestionMessages, temperature: 0.3, maxTokens: 200 }, client.apiKey)) {
+            if (chunk.type === "delta")
+                result += chunk.text;
+        }
+        const match = result.match(/\[[\s\S]*\]/);
+        if (!match)
+            return;
+        const parsed = JSON.parse(match[0]);
+        const items = Array.isArray(parsed)
+            ? parsed.filter(i => typeof i.text === "string" && i.text.length > 0).slice(0, 5)
+            : [];
+        if (items.length > 0) {
+            sendNotification("turn.suggestions", { turnId, items });
+        }
+    }
+    catch {
+        // Suggestion generation is non-critical.
+    }
+}

package/dist/cli/workflow-host-adapter.d.ts

@@ -0,0 +1,29 @@
+import type { AgentRpcError } from "../protocol/wire/index.js";
+import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
+import type { WorkflowHandlerHost } from "./handlers/workflow-handler.js";
+/**
+ * WorkflowHostAdapter — the host the legacy `workflow.*` JSON-RPC domain binds to.
+ *
+ * The workflow handlers (workflow.create/run/list/onImMessage/onWebhook/…) need MORE than the
+ * agents/solo/product sub-host provides: `toolCatalog` (workflow `tool` nodes look up real
+ * qlogicagent tools via `findTool`) plus the lazy engine slots that `ensureWorkflowController`
+ * fills (controller/store/scheduler/processManager). The multi-agent sub-host has neither, so
+ * binding workflow there left `this.toolCatalog` undefined — a workflow `tool` node would throw
+ * "Cannot read properties of undefined (reading 'findTool')" at run time. This adapter supplies
+ * the missing pieces explicitly, mirroring createDreamHostAdapter / createAcpExtendedHostAdapter.
+ *
+ * `acpDetector` is sourced from the multi-agent sub-host so workflow `agent` nodes resolve the same
+ * canonical external descriptors that the `agents.*` domain configures. The engine slots are plain
+ * own-properties this (per-agent singleton) adapter owns and `ensureWorkflowController` mutates once;
+ * keeping them here means the controller it publishes via setWorkflowController stays a singleton and
+ * the multi-agent sub-host is no longer polluted with workflow state.
+ */
+export interface WorkflowHostAdapterDeps {
+    multiAgentHost: MultiAgentHandlerHost;
+    getActiveProjectRoot(): string;
+    getToolCatalog(): WorkflowHandlerHost["toolCatalog"];
+    handleMcpToolCall: WorkflowHandlerHost["handleMcpToolCall"];
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+export declare function createWorkflowHostAdapter(deps: WorkflowHostAdapterDeps): WorkflowHandlerHost;

package/dist/cli/workflow-host-adapter.js

@@ -0,0 +1,15 @@
+export function createWorkflowHostAdapter(deps) {
+    const { multiAgentHost } = deps;
+    return {
+        get acpDetector() { return multiAgentHost.acpDetector; },
+        get toolCatalog() { return deps.getToolCatalog(); },
+        getActiveProjectRoot: deps.getActiveProjectRoot,
+        handleMcpToolCall: deps.handleMcpToolCall,
+        sendNotification: deps.sendNotification,
+        sendResponse: deps.sendResponse,
+        // Lazy multi-root engine bundles — built per project root by ensureWorkflowRoot (spec D21),
+        // owned by this adapter so the active-root controller published via setWorkflowController
+        // stays the agent-facing `workflow` tool's single track.
+        workflowRoots: null,
+    };
+}

package/dist/cli/workflow-host-adapter.test.d.ts

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

package/dist/cli/workflow-host-adapter.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from "vitest";
+import { createWorkflowHostAdapter } from "./workflow-host-adapter.js";
+describe("createWorkflowHostAdapter", () => {
+    it("supplies toolCatalog + acpDetector and owns the lazy engine slots", async () => {
+        const acpDetector = { id: "detector" };
+        const multiAgentHost = { acpDetector };
+        const toolCatalog = { findTool: () => undefined };
+        const calls = [];
+        const host = createWorkflowHostAdapter({
+            multiAgentHost,
+            getActiveProjectRoot: () => "F:\\workspace",
+            getToolCatalog: () => toolCatalog,
+            handleMcpToolCall: vi.fn(async () => "tool-result"),
+            sendNotification: (method) => calls.push(`notification:${method}`),
+            sendResponse: (id) => calls.push(`response:${id}`),
+        });
+        // The whole point of the dedicated host: workflow `tool` nodes resolve through a REAL
+        // toolCatalog (the multi-agent sub-host has none → findTool on undefined), and `agent` nodes
+        // share the canonical detector.
+        expect(host.toolCatalog).toBe(toolCatalog);
+        expect(host.acpDetector).toBe(acpDetector);
+        expect(host.getActiveProjectRoot()).toBe("F:\\workspace");
+        // Multi-root engine map starts empty and is mutable so ensureWorkflowRoot can fill it...
+        expect(host.workflowRoots).toBeNull();
+        const roots = new Map();
+        host.workflowRoots = roots;
+        expect(host.workflowRoots).toBe(roots);
+        // ...without leaking workflow state onto the multi-agent sub-host.
+        expect(multiAgentHost.workflowRoots).toBeUndefined();
+        host.sendNotification("workflow.runStarted", {});
+        host.sendResponse("rpc-1");
+        await expect(host.handleMcpToolCall("member-1", "read", {})).resolves.toBe("tool-result");
+        expect(calls).toEqual(["notification:workflow.runStarted", "response:rpc-1"]);
+    });
+});