qlogicagent 2.13.4 → 2.13.5

package/dist/cli/session-coordinator.d.ts

@@ -0,0 +1,22 @@
+import type { PathService, ToolBootstrap } from "../runtime/ports/index.js";
+import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+import { DefaultPathService } from "../runtime/infra/default-path-service.js";
+export declare class CliPathService extends DefaultPathService implements PathService {
+    private readonly mediaPersistence;
+    private readonly toolBootstrap;
+    private activeWorkdir;
+    constructor(mediaPersistence: MediaPersistence, toolBootstrap: ToolBootstrap);
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    /**
+     * The directory seeded as the file/exec tools' initial CWD: setActiveWorkdir
+     * pushes this value into toolBootstrap.setWorkdir → initCwd (the single CWD
+     * source read via getCwd()). Note this is the SEED, not the live value — an
+     * in-turn `exec("cd sub")` moves getCwd() without touching this. The permission
+     * pipeline classifies cross-workspace ops against THIS project-level dir, not
+     * getActiveProjectRoot() (also used for memory/sessions, may be a stale
+     * projectStore dir). Falls back to getActiveProjectRoot() before first set.
+     */
+    getActiveWorkdir(): string;
+    resolveProjectDir(projectId?: string): string | undefined;
+}

package/dist/cli/session-coordinator.js

@@ -0,0 +1,47 @@
+import { resolveProjectDir } from "./handlers/files-handler.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+import { resolve } from "node:path";
+import { DefaultPathService } from "../runtime/infra/default-path-service.js";
+export class CliPathService extends DefaultPathService {
+    mediaPersistence;
+    toolBootstrap;
+    activeWorkdir = null;
+    constructor(mediaPersistence, toolBootstrap) {
+        super();
+        this.mediaPersistence = mediaPersistence;
+        this.toolBootstrap = toolBootstrap;
+    }
+    getActiveProjectRoot() {
+        if (this.activeWorkdir)
+            return this.activeWorkdir;
+        const active = projectStore.getActiveProject();
+        if (active?.workspaceDir)
+            return active.workspaceDir;
+        return process.cwd();
+    }
+    setActiveWorkdir(dir) {
+        const resolved = resolve(dir);
+        if (this.activeWorkdir === resolved)
+            return;
+        this.activeWorkdir = resolved;
+        this.toolBootstrap.setWorkdir(resolved);
+        this.mediaPersistence.setProjectDir(resolved);
+    }
+    /**
+     * The directory seeded as the file/exec tools' initial CWD: setActiveWorkdir
+     * pushes this value into toolBootstrap.setWorkdir → initCwd (the single CWD
+     * source read via getCwd()). Note this is the SEED, not the live value — an
+     * in-turn `exec("cd sub")` moves getCwd() without touching this. The permission
+     * pipeline classifies cross-workspace ops against THIS project-level dir, not
+     * getActiveProjectRoot() (also used for memory/sessions, may be a stale
+     * projectStore dir). Falls back to getActiveProjectRoot() before first set.
+     */
+    getActiveWorkdir() {
+        return this.activeWorkdir ?? this.getActiveProjectRoot();
+    }
+    resolveProjectDir(projectId) {
+        if (!projectId)
+            return undefined;
+        return resolveProjectDir(projectId) ?? undefined;
+    }
+}

package/dist/cli/session-coordinator.test.d.ts

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

package/dist/cli/session-coordinator.test.js

@@ -0,0 +1,61 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("./handlers/files-handler.js", () => ({
+    resolveProjectDir: vi.fn(),
+}));
+vi.mock("../runtime/infra/project-store.js", () => ({
+    getActiveProject: vi.fn(() => ({
+        id: "stale-project",
+        workspaceDir: "C:\\Users\\81489\\AppData\\Local\\Temp\\qa-int-rapid-stale",
+    })),
+}));
+import { CliPathService } from "./session-coordinator.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+describe("CliPathService", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(projectStore.getActiveProject).mockReturnValue({
+            id: "stale-project",
+            workspaceDir: "C:\\Users\\81489\\AppData\\Local\\Temp\\qa-int-rapid-stale",
+        });
+    });
+    it("uses an explicit active workdir for subsequent turn-local project root lookups", () => {
+        const mediaPersistence = { setProjectDir: vi.fn() };
+        const toolBootstrap = { getAllBaseTools: vi.fn(), setWorkdir: vi.fn() };
+        const service = new CliPathService(mediaPersistence, toolBootstrap);
+        service.setActiveWorkdir("F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc");
+        expect(service.getActiveProjectRoot()).toBe("F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc");
+        expect(toolBootstrap.setWorkdir).toHaveBeenCalledWith("F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc");
+        expect(mediaPersistence.setProjectDir).toHaveBeenCalledWith("F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc");
+    });
+    it("getActiveWorkdir returns the exact dir pushed into the tool bootstrap workdir", () => {
+        const mediaPersistence = { setProjectDir: vi.fn() };
+        const toolBootstrap = { getAllBaseTools: vi.fn(), setWorkdir: vi.fn() };
+        const service = new CliPathService(mediaPersistence, toolBootstrap);
+        const workdir = "C:\\Users\\sunsion\\.qlogicagent\\workspaces\\default";
+        service.setActiveWorkdir(workdir);
+        // The permission classifier root must equal the tool workdir (setWorkdir target).
+        expect(service.getActiveWorkdir()).toBe(workdir);
+        expect(toolBootstrap.setWorkdir).toHaveBeenCalledWith(workdir);
+    });
+    it("getActiveWorkdir falls back to getActiveProjectRoot before first setActiveWorkdir", () => {
+        const mediaPersistence = { setProjectDir: vi.fn() };
+        const toolBootstrap = { getAllBaseTools: vi.fn(), setWorkdir: vi.fn() };
+        const service = new CliPathService(mediaPersistence, toolBootstrap);
+        // No setActiveWorkdir yet → falls back to the active-project root.
+        expect(service.getActiveWorkdir()).toBe(service.getActiveProjectRoot());
+    });
+    it("syncs bootstrap workdir even when projectStore already reports that directory", () => {
+        const workdir = "F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\active-project";
+        vi.mocked(projectStore.getActiveProject).mockReturnValue({
+            id: "active-project",
+            workspaceDir: workdir,
+        });
+        const mediaPersistence = { setProjectDir: vi.fn() };
+        const toolBootstrap = { getAllBaseTools: vi.fn(), setWorkdir: vi.fn() };
+        const service = new CliPathService(mediaPersistence, toolBootstrap);
+        service.setActiveWorkdir(workdir);
+        expect(service.getActiveProjectRoot()).toBe(workdir);
+        expect(toolBootstrap.setWorkdir).toHaveBeenCalledWith(workdir);
+        expect(mediaPersistence.setProjectDir).toHaveBeenCalledWith(workdir);
+    });
+});

package/dist/cli/session-history-coordinator.d.ts

@@ -0,0 +1,8 @@
+import type { ChatMessage } from "../agent/types.js";
+export declare class SessionHistoryCoordinator {
+    private readonly resumedSessionHistories;
+    saveResumedSession(sessionId: string, messages: readonly unknown[]): void;
+    /** Raw resumed history for a session (prior persisted turns), or [] if none. */
+    getResumedHistory(sessionId: string): ChatMessage[];
+    withResumedHistory(sessionId: string, messages: ChatMessage[]): ChatMessage[];
+}

package/dist/cli/session-history-coordinator.js

@@ -0,0 +1,57 @@
+export class SessionHistoryCoordinator {
+    resumedSessionHistories = new Map();
+    saveResumedSession(sessionId, messages) {
+        if (messages.length === 0) {
+            this.resumedSessionHistories.delete(sessionId);
+            return;
+        }
+        this.resumedSessionHistories.set(sessionId, [...messages]);
+    }
+    /** Raw resumed history for a session (prior persisted turns), or [] if none. */
+    getResumedHistory(sessionId) {
+        return this.resumedSessionHistories.get(sessionId) ?? [];
+    }
+    withResumedHistory(sessionId, messages) {
+        const resumed = this.resumedSessionHistories.get(sessionId);
+        if (!resumed || resumed.length === 0)
+            return messages;
+        const currentTail = startsWithMessages(messages, resumed)
+            ? messages.slice(resumed.length)
+            : messages;
+        return [
+            buildResumedContextMessage(resumed),
+            ...resumed,
+            ...currentTail,
+        ];
+    }
+}
+function startsWithMessages(messages, prefix) {
+    if (messages.length < prefix.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (!sameMessage(messages[i], prefix[i]))
+            return false;
+    }
+    return true;
+}
+function sameMessage(a, b) {
+    return a.role === b.role && JSON.stringify(a.content) === JSON.stringify(b.content);
+}
+function buildResumedContextMessage(resumed) {
+    const priorUserStatements = resumed
+        .filter((message) => message.role === "user" && typeof message.content === "string")
+        .map((message) => String(message.content).replace(/\s+/g, " ").trim())
+        .filter(Boolean)
+        .slice(-8);
+    const statementBlock = priorUserStatements.length > 0
+        ? ` Prior user statements recovered from this session:\n${priorUserStatements.map((line) => `- ${line.slice(0, 500)}`).join("\n")}`
+        : "";
+    return {
+        role: "system",
+        content: [
+            "Resumed session context follows. It is authoritative prior conversation for this same session.",
+            "If the current user asks about information already present there, answer directly from it before using memory or tools.",
+            statementBlock,
+        ].join(" "),
+    };
+}

package/dist/cli/session-history-coordinator.test.d.ts

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

package/dist/cli/session-history-coordinator.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { SessionHistoryCoordinator } from "./session-history-coordinator.js";
+const user = (content) => ({ role: "user", content });
+const assistant = (content) => ({ role: "assistant", content });
+describe("SessionHistoryCoordinator", () => {
+    it("prepends resumed history to legacy turn messages without mutating caller arrays", () => {
+        const coordinator = new SessionHistoryCoordinator();
+        const resumed = [user("old question"), assistant("old answer")];
+        const current = [user("new question")];
+        coordinator.saveResumedSession("session-1", resumed);
+        const result = coordinator.withResumedHistory("session-1", current);
+        expect(result).toEqual([
+            { role: "system", content: expect.stringContaining("old question") },
+            user("old question"),
+            assistant("old answer"),
+            user("new question"),
+        ]);
+        expect(current).toEqual([user("new question")]);
+    });
+    it("does not duplicate resumed history when caller already sends it", () => {
+        const coordinator = new SessionHistoryCoordinator();
+        const resumed = [user("old question"), assistant("old answer")];
+        const current = [...resumed, user("new question")];
+        coordinator.saveResumedSession("session-1", resumed);
+        const result = coordinator.withResumedHistory("session-1", current);
+        expect(result).toEqual([
+            { role: "system", content: expect.stringContaining("answer directly from it") },
+            user("old question"),
+            assistant("old answer"),
+            user("new question"),
+        ]);
+    });
+    it("ignores empty resumed histories and returns the original messages", () => {
+        const coordinator = new SessionHistoryCoordinator();
+        const current = [user("new question")];
+        coordinator.saveResumedSession("session-1", []);
+        expect(coordinator.withResumedHistory("session-1", current)).toBe(current);
+    });
+});

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

@@ -0,0 +1,24 @@
+import { SessionLocator } from "../runtime/session/session-locator.js";
+export interface SessionWorkspaceHost {
+    getActiveProjectRoot(): string;
+}
+export interface ThreadListItem {
+    id: string;
+    title?: string;
+    status: "active";
+    turnCount: number;
+    createdAt?: string;
+    lastActiveAt?: string;
+}
+export declare class SessionQueryService {
+    private readonly locator;
+    private readonly pathService;
+    constructor(locator?: SessionLocator, pathService?: import("../runtime/ports/path-service.js").PathService);
+    getActiveProjectId(): string;
+    getDefaultProjectId(): string;
+    getProjectWorkspaceDir(projectId: string): string;
+    resolveWorkspaceDir(sessionId: string, projectId?: string): string;
+    listThreads(limit: number, projectId?: string): Promise<ThreadListItem[]>;
+    resolveSessionWorkspaceDir(host: SessionWorkspaceHost, sessionId: string, projectId?: string): string;
+}
+export declare function safeSessionId(sessionId: string): string;

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

@@ -0,0 +1,57 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listSessions } from "../runtime/session/session-persistence.js";
+import { SessionLocator } from "../runtime/session/session-locator.js";
+import { getDefaultPathService } from "../runtime/infra/default-path-service.js";
+export class SessionQueryService {
+    locator;
+    pathService;
+    constructor(locator = new SessionLocator(), pathService = getDefaultPathService()) {
+        this.locator = locator;
+        this.pathService = pathService;
+    }
+    getActiveProjectId() {
+        return this.locator.getActiveProjectId();
+    }
+    getDefaultProjectId() {
+        return this.locator.getDefaultProjectId();
+    }
+    getProjectWorkspaceDir(projectId) {
+        return this.locator.getProjectWorkspaceDir(projectId);
+    }
+    resolveWorkspaceDir(sessionId, projectId) {
+        return this.locator.resolveWorkspaceDir(sessionId, projectId);
+    }
+    async listThreads(limit, projectId) {
+        const targetProjectId = projectId ?? this.getActiveProjectId();
+        const workspaceDir = this.getProjectWorkspaceDir(targetProjectId);
+        const sessions = await listSessions(limit, workspaceDir);
+        return sessions.map((session) => ({
+            id: session.sessionId,
+            title: session.title,
+            status: "active",
+            turnCount: session.messageCount,
+            createdAt: session.createdAt,
+            lastActiveAt: session.lastActiveAt,
+        }));
+    }
+    resolveSessionWorkspaceDir(host, sessionId, projectId) {
+        if (projectId)
+            return this.resolveWorkspaceDir(sessionId, projectId);
+        const activeRoot = host.getActiveProjectRoot();
+        if (activeRoot) {
+            const activeSessionDir = path.join(this.pathService.getProjectSessionsRoot(activeRoot), safeSessionId(sessionId));
+            try {
+                if (fs.existsSync(activeSessionDir))
+                    return activeRoot;
+            }
+            catch {
+                // Fall through to the project-store-backed locator.
+            }
+        }
+        return this.resolveWorkspaceDir(sessionId);
+    }
+}
+export function safeSessionId(sessionId) {
+    return sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}

package/dist/cli/skill-meta-subturn-service.d.ts

@@ -0,0 +1,26 @@
+import type { TurnEvent, TurnRequest } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
+import { type CommunitySignalReporter } from "../runtime/community/community-signal-reporter.js";
+import { type SkillSandbox } from "../runtime/sandbox/skill-sandbox.js";
+import { type SkillLifecycleRecord } from "../skills/skill-system/skill-lifecycle.js";
+export interface SkillSubturnAgent {
+    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
+}
+export interface SkillSubturnHost {
+    getAgent(): SkillSubturnAgent | null;
+    getCurrentSessionId(): string;
+    getCurrentHooks(): HookRegistry | null;
+}
+export interface ExecuteSkillSubturnParams {
+    host: SkillSubturnHost;
+    toolCatalog: ToolCatalog;
+    skillName: string;
+    skillContent: string;
+    userArgs?: string;
+    signal?: AbortSignal;
+    communitySignalReporter?: CommunitySignalReporter | null;
+    skillSandbox?: SkillSandbox | null;
+}
+export declare function executeSkillSubturn(params: ExecuteSkillSubturnParams): Promise<string>;
+export declare function resolveSkillSubagentTypeForLifecycle(skillName: string, record: SkillLifecycleRecord | undefined): string;

package/dist/cli/skill-meta-subturn-service.js

@@ -0,0 +1,93 @@
+import { randomUUID } from "node:crypto";
+import { getDefaultPathService } from "../runtime/infra/default-path-service.js";
+import { createDefaultCommunitySignalReporter } from "../runtime/community/community-signal-reporter.js";
+import { createDefaultSkillSandbox } from "../runtime/sandbox/skill-sandbox.js";
+import { trackSkillInvocation } from "../skills/skill-system/skill-source.js";
+import { loadLifecycleStore, saveLifecycleStore, recordInvocation, } from "../skills/skill-system/skill-lifecycle.js";
+export async function executeSkillSubturn(params) {
+    const { host, toolCatalog, skillName, skillContent, userArgs, signal } = params;
+    const subTurnId = `skill_${skillName}_${randomUUID().slice(0, 8)}`;
+    const subAgent = host.getAgent();
+    if (!subAgent)
+        return `[skill] Cannot execute: no LLM provider configured`;
+    const agentHome = getDefaultPathService().getOwnerProfileDir();
+    const sessionId = host.getCurrentSessionId() || "skill";
+    const lifecycleRecord = loadLifecycleStore(agentHome).records[skillName];
+    const communitySignalReporter = params.communitySignalReporter ?? createDefaultCommunitySignalReporter();
+    const sandboxDecision = (params.skillSandbox ?? createDefaultSkillSandbox()).decide({
+        origin: isCommunityInstalledSkill(lifecycleRecord) ? "community" : "first-party",
+        riskTier: lifecycleRecord?.registryEffectiveRiskTier ?? lifecycleRecord?.registryRiskTier ?? "unknown",
+        executable: true,
+        autoRun: true,
+    });
+    if (!sandboxDecision.allowed) {
+        await communitySignalReporter?.recordSkillUsage(lifecycleRecord, "fail");
+        return `[skill "${skillName}"] blocked: community ${sandboxDecision.reason} (${sandboxDecision.l0.reason ?? sandboxDecision.l0.backend})`;
+    }
+    const skillAgentType = resolveSkillSubagentTypeForLifecycle(skillName, lifecycleRecord);
+    host.getCurrentHooks()?.invoke("subagent.started", {
+        sessionId, turnId: subTurnId, subagentId: subTurnId, agentType: skillAgentType,
+    }).catch(() => { });
+    const excludedSubTools = new Set(["skill", "agent"]);
+    const subTools = toolCatalog.getToolManifest().filter(t => !excludedSubTools.has(t.function.name));
+    const userMessage = userArgs ?? `Execute skill "${skillName}" instructions.`;
+    const chunks = [];
+    let subError;
+    for await (const event of subAgent.run({
+        turnId: subTurnId,
+        sessionId,
+        messages: [{ role: "user", content: userMessage }],
+        tools: subTools,
+        systemPrompt: skillContent,
+        config: { parentDepth: 1, maxRounds: 5 },
+    }, signal)) {
+        if (event.type === "end" && event.content) {
+            recordSkillSubturnStop(host, sessionId, subTurnId, skillAgentType, "normal");
+            recordSkillInvocation(agentHome, skillName, true);
+            await communitySignalReporter?.recordSkillUsage(lifecycleRecord, "success");
+            return event.content;
+        }
+        if (event.type === "delta" && event.text)
+            chunks.push(event.text);
+        if (event.type === "error") {
+            subError = event.error;
+            break;
+        }
+    }
+    recordSkillSubturnStop(host, sessionId, subTurnId, skillAgentType, subError ? "error" : "normal", subError);
+    if (subError) {
+        trackSkillInvocation(agentHome, skillName, false);
+        await communitySignalReporter?.recordSkillUsage(lifecycleRecord, "error");
+        return `[skill "${skillName}"] error: ${subError}`;
+    }
+    recordSkillInvocation(agentHome, skillName, true);
+    await communitySignalReporter?.recordSkillUsage(lifecycleRecord, "success");
+    return chunks.join("") || `[skill "${skillName}"] completed (no output)`;
+}
+export function resolveSkillSubagentTypeForLifecycle(skillName, record) {
+    return shouldUseCommunitySkillSandbox(record) ? `community-skill:${skillName}` : `skill:${skillName}`;
+}
+function shouldUseCommunitySkillSandbox(record) {
+    return isCommunityInstalledSkill(record);
+}
+function isCommunityInstalledSkill(record) {
+    if (record?.source !== "installed")
+        return false;
+    return record.registrySourceTier !== "official";
+}
+function recordSkillSubturnStop(host, sessionId, subTurnId, skillAgentType, reason, error) {
+    host.getCurrentHooks()?.invoke("subagent.stopped", {
+        sessionId,
+        turnId: subTurnId,
+        subagentId: subTurnId,
+        agentType: skillAgentType,
+        reason,
+        error,
+    }).catch(() => { });
+}
+function recordSkillInvocation(agentHome, skillName, success) {
+    trackSkillInvocation(agentHome, skillName, success);
+    const store = loadLifecycleStore(agentHome);
+    recordInvocation(store, skillName);
+    saveLifecycleStore(agentHome, store);
+}

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

@@ -0,0 +1,34 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { MemoryLearningSink, PathService, ToolCatalog } from "../runtime/ports/index.js";
+import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
+import { type SkillSubturnAgent } from "./skill-meta-subturn-service.js";
+export { resolveSkillSubagentTypeForLifecycle } from "./skill-meta-subturn-service.js";
+export interface SkillMetaToolBootstrapDeps {
+    config: Record<string, unknown>;
+    pathService: PathService;
+    toolCatalog: ToolCatalog;
+}
+export type SkillLearningMemorySink = MemoryLearningSink;
+export interface SkillMetaToolHost {
+    getActiveProjectRoot(): string;
+    getPluginSkills(): WorkspaceSkill[];
+    getAgent(): SkillSubturnAgent | null;
+    getCurrentSessionId(): string;
+    getCurrentHooks(): HookRegistry | null;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+    getMemoryLearningSink(): SkillLearningMemorySink | null;
+    getMemoryUserId(): string;
+}
+export interface SkillMetaToolRegistrationContext extends SkillMetaToolBootstrapDeps {
+    host: SkillMetaToolHost;
+}
+export declare const skillMetaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillMetaToolRegistrationContext>;
+export declare function configureSkillMetaToolBootstrap(host: SkillMetaToolHost, deps: SkillMetaToolBootstrapDeps): void;
+/**
+ * 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 declare function resolveSupportingFilePath(skillDir: string, filePath: string): string | null;