qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/session/session-write-queue.js

@@ -0,0 +1,48 @@
+const SESSION_WRITE_CONCURRENCY = 4;
+let sessionWriteActive = 0;
+const sessionWriteQueue = [];
+const transcriptAppendTails = new Map();
+function acquireSessionWriteSlot() {
+    if (sessionWriteActive < SESSION_WRITE_CONCURRENCY) {
+        sessionWriteActive++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => sessionWriteQueue.push(resolve));
+}
+function releaseSessionWriteSlot() {
+    const next = sessionWriteQueue.shift();
+    if (next) {
+        next();
+    }
+    else {
+        sessionWriteActive--;
+    }
+}
+export async function withSessionWriteLimit(fn) {
+    await acquireSessionWriteSlot();
+    try {
+        return await fn();
+    }
+    finally {
+        releaseSessionWriteSlot();
+    }
+}
+export async function withTranscriptAppendOrder(sessionKey, fn) {
+    const previous = transcriptAppendTails.get(sessionKey) ?? Promise.resolve();
+    let releaseCurrent;
+    const currentGate = new Promise((resolve) => {
+        releaseCurrent = resolve;
+    });
+    const currentTail = previous.catch(() => { }).then(() => currentGate);
+    transcriptAppendTails.set(sessionKey, currentTail);
+    await previous.catch(() => { });
+    try {
+        return await fn();
+    }
+    finally {
+        releaseCurrent();
+        if (transcriptAppendTails.get(sessionKey) === currentTail) {
+            transcriptAppendTails.delete(sessionKey);
+        }
+    }
+}

package/dist/runtime/tasks/task-types.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Task Type Taxonomy — CC-aligned sub-agent task state system.
+ *
+ * CC defines 7 task types for sub-agent dispatch. Each type has different:
+ *   - Execution model (in-process, subprocess, remote)
+ *   - Isolation level (shared, worktree, container)
+ *   - Permission handling (interactive, coordinator, worker)
+ *   - Tool access (full, restricted, read-only)
+ *
+ * Reference: claude-code src/tasks/types.ts
+ */
+/**
+ * Sub-agent task types.
+ *
+ * PRODUCED today (have a real registration site):
+ * - local_bash:   backgrounded shell command (BackgroundTaskManager.registerBashTask)
+ * - local_agent:  backgrounded forked agent     (BackgroundTaskManager.startAgentTask)
+ * - team_member:  long-lived team subprocess     (team-tool-service → registerExternalTask)
+ * - dream:        memory consolidation           (runDream → taskStore.registerTask)
+ *
+ * PLANNED — declared for the TASK_PREFIX taxonomy + UI/protocol contract, but NO
+ * producer exists yet. Do not assume these are created anywhere; wire a producer
+ * before relying on them:
+ * - remote_agent:    cloud sandbox (polling-based)
+ * - local_workflow:  DAG/pipeline execution
+ * - monitor_mcp:     MCP server monitoring agent
+ *
+ * Naming note: we deliberately diverge from upstream CC's `in_process_teammate`.
+ * Our team members run as isolated SUBPROCESSES (AgentProcessManager) in their own
+ * git worktrees, not AsyncLocalStorage in-process agents — so the honest name is
+ * `team_member`. Keeps the `t` task-id prefix.
+ */
+export type TaskType = "local_bash" | "local_agent" | "remote_agent" | "team_member" | "local_workflow" | "monitor_mcp" | "dream";
+/**
+ * How a sub-agent is isolated from the parent execution.
+ *
+ * - shared: Same working directory, same filesystem (default fork)
+ * - worktree: Git worktree checkout — separate branch, merges back
+ * - container: Container sandbox (docker/remote)
+ */
+export type IsolationMode = "shared" | "worktree" | "container";
+/**
+ * Permission context for sub-agent execution.
+ * Determines which PermissionChecker variant is used.
+ *
+ * CC reference: 3 permission handler variants
+ * - interactive: User-facing agent, prompts for approval
+ * - coordinator: Orchestrator agent, auto-approves most non-destructive ops
+ * - worker: Headless worker, classifier-only (no user prompts)
+ */
+export type PermissionRole = "interactive" | "coordinator" | "worker";
+/** Common state fields shared by all task types. */
+export interface TaskStateBase {
+    /** Unique task ID. */
+    taskId: string;
+    /** Task type discriminant. */
+    type: TaskType;
+    /** Human-readable label. */
+    label: string;
+    /** The permission role for this task's agent. */
+    permissionRole: PermissionRole;
+    /** Isolation mode. */
+    isolation: IsolationMode;
+    /** Current lifecycle state. */
+    lifecycle: TaskLifecycle;
+    /** Parent task ID (for nested sub-agents). */
+    parentTaskId?: string;
+    /** Execution depth (0 = root). */
+    depth: number;
+    /** Maximum turns before forced stop. */
+    maxTurns: number;
+    /** Token budget for this task. */
+    tokenBudget: number;
+    /** Start timestamp (ms). */
+    startedAt: number;
+    /** End timestamp (ms), set when completed/failed. */
+    endedAt?: number;
+    /** Final output (agent answer / command output tail), set on terminal lifecycle. */
+    output?: string;
+    /** Error message, set when lifecycle is failed. */
+    error?: string;
+}
+export type TaskLifecycle = "pending" | "running" | "completed" | "failed" | "cancelled" | "timeout";
+/** Local bash task — subprocess shell execution. */
+export interface LocalBashTaskState extends TaskStateBase {
+    type: "local_bash";
+    command: string;
+    cwd: string;
+    pid?: number;
+    /** Exit code, set when the process exits. */
+    exitCode?: number;
+    /** Path to the live output file (background tasks stream here). */
+    outputPath?: string;
+}
+/** Local agent task — forked agent with its own tool loop. */
+export interface LocalAgentTaskState extends TaskStateBase {
+    type: "local_agent";
+    agentName: string;
+    systemPrompt: string;
+    /** Restricted tool set (empty = inherit parent). */
+    allowedTools: string[];
+    /** Worktree branch name (if isolation === "worktree"). */
+    worktreeBranch?: string;
+}
+/** Remote agent task — cloud sandbox execution. */
+export interface RemoteAgentTaskState extends TaskStateBase {
+    type: "remote_agent";
+    /** Remote session/environment ID. */
+    remoteSessionId: string;
+    /** Polling endpoint for status checks. */
+    pollEndpoint?: string;
+}
+/** Team member — long-lived collaborator subprocess in its own git worktree. */
+export interface TeamMemberTaskState extends TaskStateBase {
+    type: "team_member";
+    /** Team this member belongs to. */
+    teamName: string;
+    /** Member's display name. */
+    agentName: string;
+    /** Stable member id (`team-<team>-<name>`) — routes team send / cancel. */
+    memberId: string;
+    /** Subprocess PID, once spawned. */
+    pid?: number;
+    /** Isolated git worktree path (when provisioned). */
+    worktreePath?: string;
+    /** Worktree branch name (for cleanup). */
+    worktreeBranch?: string;
+}
+/** A single dream agent turn — text output + tool use count. */
+export interface DreamTurn {
+    text: string;
+    toolUseCount: number;
+}
+/** Dream phase lifecycle — CC alignment. */
+export type DreamPhase = "starting" | "updating" | "completed" | "failed";
+/** Dream task — background memory consolidation agent (CC autoDream parity). */
+export interface DreamTaskState extends TaskStateBase {
+    type: "dream";
+    sessionId: string;
+    /** Current dream phase. */
+    phase: DreamPhase;
+    /** Number of sessions being reviewed. */
+    sessionsReviewing: number;
+    /** Memory files touched by the dream agent. */
+    filesTouched: string[];
+    /** Dream agent turn history (capped). */
+    turns: DreamTurn[];
+    /** Stashed lock mtime for rollback on failure. */
+    priorLockMtime: number;
+}
+/** Placeholder for planned task types. */
+export interface PlannedTaskState extends TaskStateBase {
+    type: "local_workflow" | "monitor_mcp";
+}
+/** Union of all concrete task states. */
+export type TaskState = LocalBashTaskState | LocalAgentTaskState | RemoteAgentTaskState | TeamMemberTaskState | DreamTaskState | PlannedTaskState;
+/**
+ * Filter available tools by permission role.
+ *
+ * @param role - The agent's permission role
+ * @param availableTools - Full set of tool names
+ * @returns Filtered tool names appropriate for the role
+ */
+export declare function filterToolsByRole(role: PermissionRole, availableTools: string[]): string[];
+/** Create a new task state with defaults populated. */
+export declare function createTaskState(overrides: Pick<TaskStateBase, "taskId" | "type" | "label"> & Partial<TaskStateBase>): TaskStateBase;

package/dist/runtime/tasks/task-types.js

@@ -0,0 +1,64 @@
+/**
+ * Task Type Taxonomy — CC-aligned sub-agent task state system.
+ *
+ * CC defines 7 task types for sub-agent dispatch. Each type has different:
+ *   - Execution model (in-process, subprocess, remote)
+ *   - Isolation level (shared, worktree, container)
+ *   - Permission handling (interactive, coordinator, worker)
+ *   - Tool access (full, restricted, read-only)
+ *
+ * Reference: claude-code src/tasks/types.ts
+ */
+// ── Worker Tool Restrictions ────────────────────────────────
+/**
+ * Tool set restrictions by permission role.
+ *
+ * CC reference: Workers get Bash, Read, Edit, MCP, Skills only.
+ * Coordinators get everything including AgentTool + Team.
+ * Interactive gets full user-facing set.
+ */
+/** Tools that workers are NOT allowed to use (CC pattern). */
+const WORKER_DENIED_TOOLS = new Set([
+    "agent_tool", // No cascading forks from workers
+    "team", // No team spawning or member messaging (send action)
+    "fork_agent", // No recursive forking
+]);
+/** Tools that coordinators get in addition to full set. */
+const COORDINATOR_EXTRA_TOOLS = new Set([
+    "agent_tool", // Can spawn sub-agents
+    "team", // Can create teams and message workers (send action)
+    "task_stop", // Can stop tasks
+]);
+/**
+ * Filter available tools by permission role.
+ *
+ * @param role - The agent's permission role
+ * @param availableTools - Full set of tool names
+ * @returns Filtered tool names appropriate for the role
+ */
+export function filterToolsByRole(role, availableTools) {
+    switch (role) {
+        case "worker":
+            return availableTools.filter((t) => !WORKER_DENIED_TOOLS.has(t));
+        case "coordinator":
+            // Coordinator gets everything (ensure extra tools are included if available)
+            return [...availableTools];
+        case "interactive":
+        default:
+            return [...availableTools];
+    }
+}
+// ── Factory ─────────────────────────────────────────────────
+/** Create a new task state with defaults populated. */
+export function createTaskState(overrides) {
+    return {
+        permissionRole: "worker",
+        isolation: "shared",
+        lifecycle: "pending",
+        depth: 0,
+        maxTurns: 200,
+        tokenBudget: 0,
+        startedAt: Date.now(),
+        ...overrides,
+    };
+}

package/dist/server/search-svc.d.ts

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

package/dist/server/search-svc.js

@@ -0,0 +1,113 @@
+// ============================================================
+// search-svc — ECS 检索服务(设计 §13.1:检索层 L0/L3/缓存,纯检索 HTTP、无 LLM)。
+// 复用 agent 同一套检索模块(multi-source/searxng/stability/rerank),零代码分叉。
+// 部署:esbuild 打成单文件 → GPU ECS node:22-alpine 容器(内网端口,勿开公网,见 deploy/search-svc/)。
+//
+// 环境变量:
+//   PORT                        监听端口(默认 8890)
+//   SEARXNG_BASE_URL            上游 SearXNG(必配,如 http://172.28.166.66:8888)
+//   SEARCHSVC_REDIS_URL         可选:Redis 共享缓存(redis://:pass@host:port/db);未配用进程内缓存
+//   SEARCHSVC_CACHE_TTL_MS      可选:缓存 TTL(默认 10 分钟)
+//   SEARCHSVC_EMBEDDING_BASE_URL/_API_KEY/_MODEL/_DIMENSIONS
+//                               可选:服务端 L3 重排(openai 兼容 /embeddings);未配则不重排
+//
+// API:
+//   GET /health → { status, version, redis }
+//   GET /search?q=&maxResults=&freshness=&lang=&allowedDomains=&blockedDomains=
+//       → { query, results:[{title,url,snippet}], totalResults, tookMs }
+// ============================================================
+import { createServer } from "node:http";
+import { createMultiSourceBackend } from "../skills/web-search/multi-source-backend.js";
+import { createSearxngSource } from "../skills/web-search/searxng-source.js";
+import { InMemorySourceCache, InMemoryCircuitBreaker } from "../skills/web-search/stability.js";
+import { createRedisSourceCache } from "../skills/web-search/redis-source-cache.js";
+import { createEmbeddingReranker } from "../skills/web-search/embedding-rerank.js";
+import { ApiEmbeddingProvider } from "../skills/memory/local-embedding.js";
+const VERSION = "0.1.0";
+function buildReranker() {
+    const baseUrl = process.env.SEARCHSVC_EMBEDDING_BASE_URL?.trim();
+    const apiKey = process.env.SEARCHSVC_EMBEDDING_API_KEY?.trim();
+    const model = process.env.SEARCHSVC_EMBEDDING_MODEL?.trim();
+    if (!baseUrl || !apiKey || !model)
+        return undefined;
+    const dimensions = Number(process.env.SEARCHSVC_EMBEDDING_DIMENSIONS ?? "1024");
+    const provider = new ApiEmbeddingProvider({ baseUrl, apiKey, model, dimensions, format: "openai", timeoutMs: 8_000 });
+    return createEmbeddingReranker({ getProvider: () => provider });
+}
+async function main() {
+    const port = Number(process.env.PORT ?? 8890);
+    if (!process.env.SEARXNG_BASE_URL?.trim()) {
+        // fail-loud:检索服务没有上游就没有存在意义
+        console.error("[search-svc] FATAL: SEARXNG_BASE_URL is required");
+        process.exit(1);
+    }
+    let redis = null;
+    let cache;
+    const redisUrl = process.env.SEARCHSVC_REDIS_URL?.trim();
+    if (redisUrl) {
+        redis = await createRedisSourceCache(redisUrl);
+        cache = redis;
+        console.log(`[search-svc] cache: redis (shared)`);
+    }
+    else {
+        cache = new InMemorySourceCache();
+        console.log(`[search-svc] cache: in-memory (set SEARCHSVC_REDIS_URL for shared cache)`);
+    }
+    const rerank = buildReranker();
+    console.log(`[search-svc] rerank: ${rerank ? "embedding (server-side)" : "off (set SEARCHSVC_EMBEDDING_* to enable)"}`);
+    const backend = createMultiSourceBackend({
+        sources: [createSearxngSource()],
+        cache,
+        breaker: new InMemoryCircuitBreaker(),
+        perSourceTimeoutMs: 6_000,
+        cacheTtlMs: Number(process.env.SEARCHSVC_CACHE_TTL_MS ?? 10 * 60_000),
+        dedupe: true,
+        maxResults: 10,
+        rerank,
+    });
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        try {
+            if (url.pathname === "/health") {
+                const redisOk = redis ? await redis.ping() : "unconfigured";
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "ok", version: VERSION, redis: redisOk }));
+                return;
+            }
+            if (url.pathname === "/search") {
+                const q = url.searchParams.get("q")?.trim();
+                if (!q || q.length < 2) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "q must be at least 2 characters" }));
+                    return;
+                }
+                const freshness = url.searchParams.get("freshness");
+                const splitCsv = (v) => v?.split(",").map((s) => s.trim()).filter(Boolean);
+                const t = Date.now();
+                const out = await backend.search(q, {
+                    maxResults: Number(url.searchParams.get("maxResults") ?? "10") || 10,
+                    freshness: freshness ?? undefined,
+                    lang: url.searchParams.get("lang") ?? undefined,
+                    allowedDomains: splitCsv(url.searchParams.get("allowedDomains")),
+                    blockedDomains: splitCsv(url.searchParams.get("blockedDomains")),
+                });
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ ...out, tookMs: Date.now() - t }));
+                return;
+            }
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "not found" }));
+        }
+        catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+    });
+    server.listen(port, () => {
+        console.log(`[search-svc] v${VERSION} listening on :${port} (upstream: ${process.env.SEARXNG_BASE_URL})`);
+    });
+}
+main().catch((err) => {
+    console.error("[search-svc] FATAL:", err);
+    process.exit(1);
+});

package/dist/skills/index.d.ts

@@ -0,0 +1,6 @@
+export type { PortableTool, PortableToolResult, ToolContentBlock, } from "./portable-tool.js";
+export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent, } from "./tool-access.js";
+export type { ParsedSkillFrontmatter, WorkspaceSkill, SkillInstallSpec, SkillMetadata, SkillInvocationPolicy, SkillCommandDispatchSpec, SkillCommandSpec, SkillScanSeverity, SkillScanFinding, SkillScanSummary, SkillScanOptions, SkillFsDeps, SkillPathDeps, } from "./skill-system/skill-types.js";
+export { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy, resolveSkillKey, } from "./skill-system/skill-frontmatter.js";
+export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } from "./skill-system/skill-guard.js";
+export type { SkillGuardDeps } from "./skill-system/skill-guard.js";

package/dist/skills/index.js

@@ -0,0 +1,5 @@
+// Stable public surface for qlogicagent skills.
+// Runtime and CLI code should import concrete internals from their owning modules.
+export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent, } from "./tool-access.js";
+export { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy, resolveSkillKey, } from "./skill-system/skill-frontmatter.js";
+export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } from "./skill-system/skill-guard.js";

package/dist/skills/mcp/index.d.ts

@@ -0,0 +1 @@
+export { McpManager, parseMcpConfig, validateMcpToolWorkspaceBoundary, type McpServerEntry, type McpManagerConfig } from "./mcp-manager.js";

package/dist/skills/mcp/index.js

@@ -0,0 +1,3 @@
+// MCP module barrel exports — mcporter-backed manager only; the protocol
+// layer lives in mcporter (official @modelcontextprotocol/sdk underneath).
+export { McpManager, parseMcpConfig, validateMcpToolWorkspaceBoundary } from "./mcp-manager.js";

package/dist/skills/mcp/mcp-manager.d.ts

@@ -0,0 +1,75 @@
+import type { PortableTool } from "../portable-tool.js";
+interface ToolRegistryLike {
+    addTools(tools: PortableTool[]): void;
+    getToolNames(): string[];
+    removeTool(name: string): boolean;
+}
+export interface McpServerEntry {
+    /** Server display name */
+    name: string;
+    /** Transport type: "stdio" (default) or "http" */
+    type?: "stdio" | "http";
+    /** Command to spawn (stdio only) */
+    command?: string;
+    /** Command arguments (stdio only) */
+    args?: string[];
+    /** Extra environment variables (stdio only) */
+    env?: Record<string, string>;
+    /** Working directory for stdio MCP subprocesses */
+    cwd?: string;
+    /** HTTP endpoint URL (http only) */
+    url?: string;
+    /** Extra HTTP headers (http only) */
+    headers?: Record<string, string>;
+    /** Init timeout (ms) — accepted for config compatibility; mcporter owns connect timeouts. */
+    initTimeoutMs?: number;
+    /** Whether this server is disabled (skip connection) */
+    disabled?: boolean;
+}
+export interface McpManagerConfig {
+    servers: McpServerEntry[];
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+    /** Active workspace boundary for local-path arguments passed into MCP tools. */
+    workspaceRoot?: string;
+    /** Runtime-owned catalog used for dynamic MCP tool injection. */
+    toolCatalog?: ToolRegistryLike;
+}
+export declare class McpManager {
+    private runtime;
+    private definitions;
+    private toolsByServer;
+    private injectedNames;
+    private log;
+    private workspaceRoot?;
+    private toolCatalog?;
+    constructor(config: McpManagerConfig);
+    private toServerDefinition;
+    /**
+     * Connect to all configured MCP servers and snapshot their tools.
+     * Per-server failures are logged but don't block the rest.
+     */
+    connectAll(): Promise<void>;
+    /**
+     * Register all snapshotted MCP tools into the tool pool.
+     */
+    injectTools(): void;
+    /** Get names of all connected servers. */
+    getConnectedServers(): string[];
+    /** Get total number of MCP tools across all servers. */
+    getToolCount(): number;
+    /**
+     * Close all MCP connections and retract the injected tools, so a config
+     * reload never leaves ghost tools bound to a closed runtime.
+     */
+    disconnectAll(): Promise<void>;
+    private toPortableTool;
+    private wrapToolsForWorkspaceBoundary;
+    private registerTools;
+    private removeRegisteredTool;
+}
+export declare function validateMcpToolWorkspaceBoundary(toolName: string, args: unknown, workspaceRoot: string | undefined): string | null;
+export declare function parseMcpConfig(json: unknown): McpServerEntry[];
+export {};