qlogicagent 2.13.5 → 2.13.6

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,35 +0,0 @@
-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"]);
-    });
-});