qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/product-budget.js

@@ -1,112 +0,0 @@
-/**
- * Product Budget — token/time budget enforcement for Product Mode.
- *
- * Tracks cumulative token usage and elapsed time across all agent instances.
- * Emits 80% warning and enforces 100% hard limit.
- */
-export class ProductBudgetTracker {
-    maxTotalTokens;
-    maxDuration;
-    usedTokens = 0;
-    startedAt;
-    warningEmitted = false;
-    constructor(budget) {
-        this.maxTotalTokens = budget?.maxTotalTokens;
-        this.maxDuration = budget?.maxDuration;
-        this.startedAt = Date.now();
-    }
-    /** Add tokens from a usage tracker snapshot. */
-    addUsage(inputTokens, outputTokens) {
-        this.usedTokens += inputTokens + outputTokens;
-    }
-    /** Add tokens from an ACP usage tracker. */
-    addFromTracker(tracker) {
-        if (!tracker.hasData())
-            return;
-        const u = tracker.getUsage();
-        this.usedTokens += u.totalTokens;
-    }
-    /** Get current elapsed time in ms. */
-    getElapsed() {
-        return Date.now() - this.startedAt;
-    }
-    /** Get the budget snapshot. */
-    getBudget() {
-        return {
-            maxTotalTokens: this.maxTotalTokens,
-            maxDuration: this.maxDuration,
-            usedTokens: this.usedTokens,
-            elapsed: this.getElapsed(),
-        };
-    }
-    /**
-     * Check budget status. Returns:
-     * - "ok": within budget
-     * - "warning": 80%+ but not exceeded
-     * - "exceeded": over 100%, should pause
-     */
-    check() {
-        const elapsed = this.getElapsed();
-        // Time check
-        if (this.maxDuration && elapsed >= this.maxDuration) {
-            return {
-                action: "exceeded",
-                percentage: Math.round((elapsed / this.maxDuration) * 100),
-                usedTokens: this.usedTokens,
-                maxTotalTokens: this.maxTotalTokens,
-                elapsed,
-                maxDuration: this.maxDuration,
-            };
-        }
-        // Token check
-        if (this.maxTotalTokens) {
-            const pct = Math.round((this.usedTokens / this.maxTotalTokens) * 100);
-            if (this.usedTokens >= this.maxTotalTokens) {
-                return {
-                    action: "exceeded",
-                    percentage: pct,
-                    usedTokens: this.usedTokens,
-                    maxTotalTokens: this.maxTotalTokens,
-                    elapsed,
-                    maxDuration: this.maxDuration,
-                };
-            }
-            if (pct >= 80 && !this.warningEmitted) {
-                this.warningEmitted = true;
-                return {
-                    action: "warning",
-                    percentage: pct,
-                    usedTokens: this.usedTokens,
-                    maxTotalTokens: this.maxTotalTokens,
-                    elapsed,
-                    maxDuration: this.maxDuration,
-                };
-            }
-        }
-        const pct = this.maxTotalTokens
-            ? Math.round((this.usedTokens / this.maxTotalTokens) * 100)
-            : 0;
-        return {
-            action: "ok",
-            percentage: pct,
-            usedTokens: this.usedTokens,
-            maxTotalTokens: this.maxTotalTokens,
-            elapsed,
-            maxDuration: this.maxDuration,
-        };
-    }
-    /** Restore from persisted budget data. */
-    restore(data) {
-        this.usedTokens = data.usedTokens;
-        this.startedAt = data.startedAt;
-        this.warningEmitted = data.warningEmitted;
-    }
-    /** Serialize for persistence. */
-    serialize() {
-        return {
-            usedTokens: this.usedTokens,
-            startedAt: this.startedAt,
-            warningEmitted: this.warningEmitted,
-        };
-    }
-}

package/dist/orchestration/product-checkpoint.d.ts

@@ -1,46 +0,0 @@
-/**
- * Product Checkpoint — automatic and manual checkpoint triggers.
- *
- * Rules:
- *  - Auto-checkpoint on task completion
- *  - 5 min fallback timer for active products
- *  - 30 min timer for long-running products (>48h)
- *  - Manual checkpoint via product.checkpoint RPC
- */
-import type { PersistedProductState } from "./product-persistence.js";
-export interface CheckpointCallbacks {
-    /** Called after each checkpoint save. */
-    onCheckpoint?: (productId: string, timestamp: string) => void;
-    /** Return current state snapshot for periodic auto-saves. */
-    getState?: () => PersistedProductState | null;
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-export declare class ProductCheckpointManager {
-    private callbacks;
-    /** Fallback interval (5 min default, 30 min for >48h long-running). */
-    private static readonly DEFAULT_INTERVAL;
-    private static readonly LONG_RUNNING_INTERVAL;
-    private static readonly LONG_RUNNING_THRESHOLD;
-    private timer;
-    private lastCheckpointAt;
-    private cwd?;
-    constructor(callbacks?: CheckpointCallbacks);
-    /** Start periodic checkpointing for a product. */
-    start(cwd?: string): void;
-    /** Stop periodic checkpointing. */
-    stop(): void;
-    /** Get the appropriate checkpoint interval based on elapsed time. */
-    getInterval(elapsedMs: number): number;
-    /** Check if a checkpoint is due based on elapsed time since last checkpoint. */
-    isDue(elapsedMs: number): boolean;
-    /**
-     * Perform a checkpoint: save state to disk and notify.
-     * Called on task completion or by periodic timer.
-     */
-    checkpoint(state: PersistedProductState): Promise<void>;
-    /** Get the time of last checkpoint. */
-    getLastCheckpointAt(): number;
-}

package/dist/orchestration/product-checkpoint.js

@@ -1,74 +0,0 @@
-/**
- * Product Checkpoint — automatic and manual checkpoint triggers.
- *
- * Rules:
- *  - Auto-checkpoint on task completion
- *  - 5 min fallback timer for active products
- *  - 30 min timer for long-running products (>48h)
- *  - Manual checkpoint via product.checkpoint RPC
- */
-import { saveProductState } from "./product-persistence.js";
-export class ProductCheckpointManager {
-    callbacks;
-    /** Fallback interval (5 min default, 30 min for >48h long-running). */
-    static DEFAULT_INTERVAL = 5 * 60_000;
-    static LONG_RUNNING_INTERVAL = 30 * 60_000;
-    static LONG_RUNNING_THRESHOLD = 48 * 60 * 60_000;
-    timer = null;
-    lastCheckpointAt = 0;
-    cwd;
-    constructor(callbacks = {}) {
-        this.callbacks = callbacks;
-    }
-    /** Start periodic checkpointing for a product. */
-    start(cwd) {
-        this.cwd = cwd;
-        this.stop(); // clear any existing timer
-        this.timer = setInterval(() => {
-            const state = this.callbacks.getState?.();
-            if (!state)
-                return;
-            this.checkpoint(state).catch(err => {
-                this.callbacks.log?.warn(`[checkpoint] periodic save failed: ${err instanceof Error ? err.message : String(err)}`);
-            });
-        }, ProductCheckpointManager.DEFAULT_INTERVAL);
-        // Ensure timer doesn't prevent process exit
-        this.timer.unref();
-    }
-    /** Stop periodic checkpointing. */
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    /** Get the appropriate checkpoint interval based on elapsed time. */
-    getInterval(elapsedMs) {
-        return elapsedMs > ProductCheckpointManager.LONG_RUNNING_THRESHOLD
-            ? ProductCheckpointManager.LONG_RUNNING_INTERVAL
-            : ProductCheckpointManager.DEFAULT_INTERVAL;
-    }
-    /** Check if a checkpoint is due based on elapsed time since last checkpoint. */
-    isDue(elapsedMs) {
-        if (this.lastCheckpointAt === 0)
-            return true;
-        const interval = this.getInterval(elapsedMs);
-        return (Date.now() - this.lastCheckpointAt) >= interval;
-    }
-    /**
-     * Perform a checkpoint: save state to disk and notify.
-     * Called on task completion or by periodic timer.
-     */
-    async checkpoint(state) {
-        const timestamp = new Date().toISOString();
-        state.lastCheckpointAt = timestamp;
-        await saveProductState(state, this.cwd);
-        this.lastCheckpointAt = Date.now();
-        this.callbacks.onCheckpoint?.(state.productId, timestamp);
-        this.callbacks.log?.info(`[checkpoint] saved ${state.productId} at ${timestamp}`);
-    }
-    /** Get the time of last checkpoint. */
-    getLastCheckpointAt() {
-        return this.lastCheckpointAt;
-    }
-}

package/dist/orchestration/product-dag-mutation-applier.d.ts

@@ -1,10 +0,0 @@
-import type { DagMutation } from "./product-planner.js";
-import type { DagScheduler } from "./dag-scheduler.js";
-export interface ProductDagMutationApplyResult {
-    applied: DagMutation[];
-    errors: Array<{
-        mutation: DagMutation;
-        error: string;
-    }>;
-}
-export declare function applyProductDagMutations(dag: DagScheduler, mutations: readonly DagMutation[]): ProductDagMutationApplyResult;

package/dist/orchestration/product-dag-mutation-applier.js

@@ -1,91 +0,0 @@
-function mutationPatch(mutation) {
-    const details = mutation.details ?? {};
-    switch (mutation.type) {
-        case "update_prompt": {
-            const prompt = details["prompt"];
-            return typeof prompt === "string" ? { prompt } : {};
-        }
-        case "reassign_task": {
-            const assignee = details["assignee"] ?? details["agentId"];
-            return typeof assignee === "string" ? { agentId: assignee } : {};
-        }
-        default:
-            return {};
-    }
-}
-function buildNodeDef(mutation) {
-    const details = mutation.details ?? {};
-    const task = (typeof details["task"] === "object" && details["task"] !== null)
-        ? details["task"]
-        : details;
-    const id = String(task["taskId"] ?? task["id"] ?? mutation.taskId);
-    const assignee = String(task["assignee"] ?? task["agentId"] ?? "");
-    const prompt = String(task["prompt"] ?? task["description"] ?? "");
-    const dependsOn = Array.isArray(task["dependsOn"]) ? task["dependsOn"].map(String) : undefined;
-    return {
-        id,
-        kind: "agent",
-        params: { agentId: assignee, prompt },
-        dependsOn,
-    };
-}
-function canPatchDirectly(node) {
-    return !!node && node.status === "pending";
-}
-export function applyProductDagMutations(dag, mutations) {
-    const applied = [];
-    const errors = [];
-    const deferredFailedPatches = new Map();
-    for (const mutation of mutations) {
-        try {
-            switch (mutation.type) {
-                case "add_task":
-                    dag.addNode(buildNodeDef(mutation));
-                    applied.push(mutation);
-                    break;
-                case "remove_task":
-                    dag.removeNode(mutation.taskId);
-                    applied.push(mutation);
-                    break;
-                case "update_prompt":
-                case "reassign_task": {
-                    const patch = mutationPatch(mutation);
-                    if (Object.keys(patch).length === 0) {
-                        throw new Error(`${mutation.type} requires a valid patch`);
-                    }
-                    const node = dag.getNode(mutation.taskId);
-                    if (canPatchDirectly(node)) {
-                        dag.updateNodeParams(mutation.taskId, patch);
-                    }
-                    else if (node?.status === "failed") {
-                        deferredFailedPatches.set(mutation.taskId, {
-                            ...(deferredFailedPatches.get(mutation.taskId) ?? {}),
-                            ...patch,
-                        });
-                    }
-                    else {
-                        throw new Error(`Task "${mutation.taskId}" is ${node?.status ?? "missing"}, cannot patch`);
-                    }
-                    applied.push(mutation);
-                    break;
-                }
-                case "retry_task": {
-                    const patch = deferredFailedPatches.get(mutation.taskId);
-                    dag.retryNode(mutation.taskId, patch);
-                    deferredFailedPatches.delete(mutation.taskId);
-                    applied.push(mutation);
-                    break;
-                }
-                default:
-                    throw new Error(`Unknown mutation type: ${mutation.type}`);
-            }
-        }
-        catch (err) {
-            errors.push({
-                mutation,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    return { applied, errors };
-}

package/dist/orchestration/product-persistence.d.ts

@@ -1,35 +0,0 @@
-/**
- * Product Persistence — read/write Product Mode state to disk.
- *
- * State is stored at `<project>/.qlogicagent/products/<productId>/product-state.json`.
- * Product listing is done by enumerating subdirectories.
- */
-import type { PathService } from "../runtime/ports/index.js";
-import type { ProductPhase, ProductInstanceDef } from "../protocol/wire/acp-agent-management.js";
-import type { SerializedNode } from "./dag-scheduler.js";
-export interface PersistedProductState {
-    productId: string;
-    name: string;
-    phase: ProductPhase;
-    cwd: string;
-    instances: ProductInstanceDef[];
-    tasks: SerializedNode[];
-    budget: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-        usedTokens: number;
-        startedAt: number;
-        warningEmitted: boolean;
-    };
-    createdAt: string;
-    lastCheckpointAt: string;
-}
-export interface ProductPersistenceOptions {
-    pathService?: PathService;
-}
-/** Save product state to disk. */
-export declare function saveProductState(state: PersistedProductState, cwd?: string, options?: ProductPersistenceOptions): Promise<void>;
-/** Load product state from disk. Returns undefined if not found. */
-export declare function loadProductState(productId: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
-/** List all product IDs with their persisted state. */
-export declare function listProducts(cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState[]>;

package/dist/orchestration/product-persistence.js

@@ -1,55 +0,0 @@
-/**
- * Product Persistence — read/write Product Mode state to disk.
- *
- * State is stored at `<project>/.qlogicagent/products/<productId>/product-state.json`.
- * Product listing is done by enumerating subdirectories.
- */
-import { join } from "node:path";
-import { mkdir, readdir } from "node:fs/promises";
-import { readJsonFile, writeJsonFile } from "../runtime/infra/disk-storage.js";
-import { getDefaultPathService } from "../runtime/infra/default-path-service.js";
-function resolvePathService(options) {
-    return options?.pathService ?? getDefaultPathService();
-}
-function resolveProjectRoot(cwd, pathService) {
-    return cwd ?? pathService.getActiveProjectRoot();
-}
-function getProductsDir(cwd, options) {
-    const pathService = resolvePathService(options);
-    return join(pathService.getProjectAgentDir(resolveProjectRoot(cwd, pathService)), "products");
-}
-function getProductDir(productId, cwd, options) {
-    return join(getProductsDir(cwd, options), productId);
-}
-function getStatePath(productId, cwd, options) {
-    return join(getProductDir(productId, cwd, options), "product-state.json");
-}
-// ── Public API ──────────────────────────────────────────────
-/** Save product state to disk. */
-export async function saveProductState(state, cwd, options) {
-    const dir = getProductDir(state.productId, cwd, options);
-    await mkdir(dir, { recursive: true });
-    await writeJsonFile(getStatePath(state.productId, cwd, options), state);
-}
-/** Load product state from disk. Returns undefined if not found. */
-export async function loadProductState(productId, cwd, options) {
-    return readJsonFile(getStatePath(productId, cwd, options));
-}
-/** List all product IDs with their persisted state. */
-export async function listProducts(cwd, options) {
-    const dir = getProductsDir(cwd, options);
-    let entries;
-    try {
-        entries = await readdir(dir);
-    }
-    catch {
-        return [];
-    }
-    const products = [];
-    for (const entry of entries) {
-        const state = await loadProductState(entry, cwd, options);
-        if (state)
-            products.push(state);
-    }
-    return products;
-}

package/dist/orchestration/product-planner.d.ts

@@ -1,146 +0,0 @@
-/**
- * Product Planner — Interactive multi-turn planning + persistent leader management.
- *
- * Architecture (aligned with CrewAI hierarchical + LangGraph durable execution):
- *
- * Phase 1 — PLANNING (multi-turn dialogue):
- *   1. product.plan → spawn leader agent → leader engages user in multi-turn dialogue
- *   2. Leader asks clarifying questions, proposes module decomposition
- *   3. User responds via product.message → leader refines plan
- *   4. Leader outputs structured plan → client presents to user
- *
- * Phase 2 — CONFIRMATION:
- *   5. product.confirm → user confirms/modifies plan → transition to execution
- *
- * Phase 3 — EXECUTION (leader as persistent manager):
- *   6. Leader manages DAG: dispatches tasks, monitors, handles failures
- *   7. Leader can dynamically mutate DAG: add/retry/reassign tasks
- *   8. User can intervene via product.message at any time
- *   9. Each state transition is checkpointed for crash recovery
- *
- * Key mechanisms from reference projects:
- *   - CrewAI: hierarchical process (manager auto-delegates/verifies)
- *   - CrewAI: checkpoint serialization (mid-task state)
- *   - LangGraph: durable execution (persist after each node)
- */
-import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
-import type { AcpDetector } from "../runtime/infra/acp-detector.js";
-import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
-import type { ProductPlanParams, ProductPlan, ProductConfirmParams } from "../protocol/wire/acp-agent-management.js";
-export type PlanningPhase = "planning" | "awaiting_confirmation" | "confirmed" | "executing" | "paused" | "completed" | "cancelled";
-export interface PlanningMessage {
-    role: "leader" | "user";
-    content: string;
-    timestamp: string;
-}
-export interface PlanningSession {
-    productId: string;
-    goal: string;
-    cwd: string;
-    leaderAgentId: string;
-    leaderMemberId?: string;
-    phase: PlanningPhase;
-    plan?: ProductPlan;
-    /** Multi-turn conversation history during planning. */
-    dialogue: PlanningMessage[];
-    budget?: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-    };
-    createdAt: string;
-    /** Last checkpoint timestamp for durable execution. */
-    lastCheckpoint?: string;
-}
-export interface PlannerCallbacks {
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-    /** Leader produced a structured plan — client presents to user. */
-    onPlanReady?: (productId: string, plan: ProductPlan) => void;
-    /** Planning failed. */
-    onPlanFailed?: (productId: string, error: string) => void;
-    /** Streaming text from leader during planning dialogue. */
-    onPlanningDelta?: (productId: string, text: string) => void;
-    /** Leader sent a message to user (multi-turn). */
-    onLeaderMessage?: (productId: string, message: string) => void;
-    /** Leader dynamically mutated the DAG during execution. */
-    onDagMutated?: (productId: string, mutation: DagMutation) => void;
-}
-/** Describes a DAG mutation performed by the leader. */
-export interface DagMutation {
-    type: "add_task" | "remove_task" | "retry_task" | "reassign_task" | "update_prompt";
-    taskId: string;
-    details?: Record<string, unknown>;
-}
-export declare class ProductPlanner {
-    private processManager;
-    private acpDetector;
-    private configStore;
-    private callbacks;
-    private sessions;
-    constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: PlannerCallbacks);
-    /**
-     * Start an interactive planning session (Phase 1).
-     * Spawns the leader agent and begins multi-turn dialogue.
-     */
-    plan(params: ProductPlanParams): Promise<{
-        productId: string;
-        plan: ProductPlan;
-    }>;
-    /**
-     * Send a user message to the leader (works in planning and execution phases).
-     * Returns the leader's response and optionally a finalized plan.
-     */
-    message(productId: string, content: string): Promise<{
-        response: string;
-        plan?: ProductPlan;
-        mutations?: DagMutation[];
-    }>;
-    /**
-     * Confirm the plan → transition to execution (Phase 2 → Phase 3).
-     */
-    confirm(params: ProductConfirmParams): Promise<{
-        productId: string;
-        ok: true;
-    }>;
-    /** Transition session to executing phase. Called after ProductOrchestrator.create(). */
-    markExecuting(productId: string): void;
-    /** Mark as completed. */
-    markCompleted(productId: string): void;
-    /** Get planning session by ID. */
-    getSession(productId: string): PlanningSession | undefined;
-    /** Cancel and kill leader process. */
-    cancel(productId: string): Promise<void>;
-    /** List active sessions. */
-    listSessions(): PlanningSession[];
-    /**
-     * Ask leader to evaluate execution state and propose DAG mutations.
-     * Called by ProductOrchestrator when tasks fail or progress stalls.
-     */
-    consultLeader(productId: string, context: {
-        progress: {
-            total: number;
-            completed: number;
-            running: number;
-            failed: number;
-        };
-        failedTasks?: Array<{
-            taskId: string;
-            error: string;
-        }>;
-    }): Promise<DagMutation[]>;
-    /**
-     * Serialize session for checkpoint persistence (durable execution).
-     */
-    serializeSession(productId: string): PlanningSession | null;
-    /**
-     * Restore session from checkpoint (crash recovery).
-     */
-    restoreSession(data: PlanningSession): void;
-    private handlePlanningMessage;
-    private handleExecutionMessage;
-    private sendToLeader;
-    private tryParsePlan;
-    private parseDagMutations;
-}