qlogicagent 2.24.1 → 2.24.2

package/dist/types/orchestration/solo-evaluator.d.ts

@@ -1,179 +0,0 @@
-/**
- * Solo Mode Evaluator — parallel N-agent PK with user-triggered evaluation.
- *
- * Flow:
- *   1. solo.start → create N isolated git worktrees, spawn N agents in parallel
- *   2. Each agent receives the same task prompt in its own worktree
- *      (all agents share initial config: memory/rules from project .qlogicagent/)
- *   3. On completion of initial task, agents enter "idle" state (process kept alive)
- *   4. User can send follow-up messages to individual agents via solo.message
- *   5. User triggers evaluation via solo.evaluate (or skips directly to solo.select)
- *   6. solo.select → materialize the winner's worktree changes into the workspace, clean up all
- *      worktrees + solo/* branches
- *
- * Key design:
- *   - Solo = special project type persisted by the Gateway RunState authority
- *   - Agents share the same initial config but operate in isolated worktrees
- *   - User controls the evaluation timing (not automatic)
- *   - Follow-up instructions to individual agents supported
- *
- * Degradation: if K agents fail but ≥1 succeeds, session remains interactive.
- */
-import type { DelegateBridge } from "./delegate-bridge.js";
-import type { SoloState, SoloAgentState, SoloEvaluation, SoloStatus, SoloStartParams, SoloSelectParams, SoloSpec } from "../protocol/wire/acp-agent-management.js";
-export interface SoloCallbacks {
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-        debug?(msg: string): void;
-    };
-    onProgress?: (soloId: string, agentId: string, state: SoloAgentState, progress: string | undefined, worktreePath: string | undefined, projectId: string) => void;
-    onEvaluation?: (soloId: string, evaluation: SoloEvaluation, projectId: string) => void | Promise<void>;
-    /** Streaming text delta from a competing agent (forwarded from child process). */
-    onAgentDelta?: (soloId: string, agentId: string, text: string) => void;
-    /** Live tool-activity heartbeat emitted from the supervised delegate event sink. */
-    onAgentActivity?: (soloId: string, agentId: string, toolName: string) => void;
-    /** Token usage report after agent completes. */
-    onAgentUsage?: (soloId: string, agentId: string, inputTokens: number, outputTokens: number) => void;
-    /** Full (capped) unified diff of a competitor's worktree once a turn settles — the same diff the
-     *  judge scores, so the user can inspect actual changes instead of only the agent's self-report. */
-    onAgentDiff?: (soloId: string, agentId: string, diff: string) => void;
-    /** Run-level state transition (running/evaluating/…): lets the UI narrate the auto-judge phase. */
-    onState?: (soloId: string, state: SoloState, projectId: string) => void;
-    /** Required Gateway delegate access; Solo fails loud when the Host rail is unavailable. */
-    getDelegateBridge?: () => DelegateBridge | undefined;
-    /** Ready (launchable) agent provider ids — used to prefer an INDEPENDENT judge over a competitor
-     *  scoring its own race. Best effort: absent/failing falls back to a participant judge. */
-    listReadyAgentIds?: () => Promise<string[]>;
-    /**
-     * Race reached a terminal state WITHOUT an evaluation winner (all agents failed, or cancelled).
-     * The success path uses onEvaluation; this lets the host write back the plan project's planStatus
-     * (failed/cancelled) so 历史方案 is correct and recovery doesn't restore a dead run.
-     */
-    onTerminal?: (soloId: string, state: SoloState, projectId: string) => void | Promise<void>;
-}
-/**
- * Solo is an explicit user-launched coding race and every racer is confined to its own disposable
- * worktree. Permit a requested operation only for this turn; never upgrade the decision to a
- * persistent allow. If the agent offers no one-shot allow, fail closed with a rejection option.
- */
-export declare function selectSoloApprovalOptionId(options: Array<Record<string, unknown>>): string;
-/**
- * Assemble the prompt every competitor receives (Cut4). Shared context (rules/memory) + optional
- * <spec> block, then the body. Body = spec.rawTask when a Spec was built (the task captured during
- * specBuild), else the raw task. With neither sharedConfig nor spec the result is exactly `task`
- * (regression-safe vs the pre-Spec path).
- */
-export declare function buildEnrichedTask(task: string, sharedConfig: {
-    memory?: string[];
-    rules?: string[];
-    model?: string;
-} | undefined, spec: SoloSpec | undefined): string;
-/**
- * Build the judge prompt (Cut4). When the Spec defines acceptance criteria, the judge scores
- * per-criterion (满足/部分/不满足) instead of a subjective compare. The WINNER:/REASONING: output
- * markers are unchanged so parseEvaluationResponse still works — only the basis of REASONING upgrades.
- */
-export declare function buildEvaluationPrompt(originalTask: string, spec: SoloSpec | undefined, succeeded: ReadonlyArray<{
-    displayId: string;
-    resultText?: string;
-    diff?: string;
-}>): string;
-export declare class SoloEvaluator {
-    private callbacks;
-    private sessions;
-    private persistenceTails;
-    constructor(callbacks?: SoloCallbacks);
-    private snapshotSession;
-    private queuePersistSession;
-    private publishNotification;
-    /** Announce the run-level state so the UI can narrate phases (esp. the auto-judge window). */
-    private publishState;
-    /**
-     * Resolve a session, lazily rehydrating from the Host RunState checkpoint after an engine
-     * restart — without this, every restart turned live races into zombies (uncancellable,
-     * unadoptable, undeletable, forever "运行中" in history).
-     *
-     * A restart killed the racer processes, so a checkpointed "running"/"pending" agent can never
-     * settle: mark it failed to make the run actionable. Same for a mid-flight "evaluating" run —
-     * the judge turn is gone; drop back to "running" so select/cancel/evaluate stay available.
-     */
-    private requireSession;
-    /**
-     * Start a Solo Mode PK session.
-     * Creates worktrees, spawns agents in parallel, waits for completion, then evaluates.
-     */
-    start(params: SoloStartParams): Promise<string>;
-    /**
-     * 激活层(active Host path §1.5):gateway-routed delegate 路径 —— 竞速者回合经网关代派(x/delegate),不本地
-     * spawn。同 handle(solo-racer/soloId/agentId/seq)⇒ supervisor 按 memberKey 复用同一竞速者进程与
-     * ACP 会话:初赛 → follow-up → 评比全程上下文连续(取代旧「watchdog reap + 按需 re-spawn」循环,
-     * worktree 文件仍是 durable state)。cwd=worktree;self 竞速者的 QLOGICAGENT_WORKTREE_WORKDIR /
-     * QLOGICAGENT_SOLO_LEAN 由 gateway 按 kind=solo-racer 派生注入(AgentSpec.envOverrides,current contract
-     * —— descriptor/env 注入在 qla 侧退场,env 是监督者按成员种类决定的启动器不变量,非调用方入参)。
-     * usage 由 TurnResult.usage 承(不再读共享 PM 的 usage tracker)。
-     */
-    private runTurnViaDelegate;
-    /**
-     * Ensure the agent's ACP process is alive in its worktree, spawning it if absent. Used by the
-     * initial run AND by follow-up messages: the watchdog reaps idle competitors after the race, so a
-     * follow-up almost always arrives after the process is gone. The worktree (its files) is the durable
-     * state, so re-spawning there lets follow-ups keep working for the whole session — not just in the
-     * brief window before reaping. Self-agent gets the worktree-workdir + lean env (see runOne notes):
-     * QLOGICAGENT_WORKTREE_WORKDIR anchors writes to the worktree; QLOGICAGENT_SOLO_LEAN drops media
-     * tools so it matches the external coding CLIs and won't wander into 图像生成 on a code task.
-     */
-    /**
-     * Send a follow-up message to a specific agent within a solo session.
-     * Agent must be in "idle" or "completed" state.
-     */
-    message(soloId: string, agentId: string, content: string, agentIndex?: number): Promise<{
-        resultText: string;
-    }>;
-    /**
-     * User-triggered evaluation — compare all completed/idle agents' results.
-     * The user chooses which agent in the session performs the evaluation comparison.
-     */
-    triggerEvaluation(soloId: string, evaluatorAgentId: string, evaluatorIndex?: number): Promise<SoloEvaluation>;
-    /** Map a spawned member back to its solo run + UI column id (for live delta forwarding). */
-    getMemberContext(memberId: string): {
-        soloId: string;
-        displayId: string;
-    } | null;
-    /**
-     * Replay each in-flight agent's already-streamed turn text (reconnect/refresh resume). The status
-     * snapshot only carries SETTLED turn text; this hands back what the current turn has produced so
-     * far, so a refresh mid-race doesn't blank the streaming columns until the next delta.
-     */
-    replayLiveText(soloId: string, emit: (agentDisplayId: string, text: string) => void): Promise<void>;
-    /** Get the current status of a solo session. */
-    getStatus(soloId: string): SoloStatus | null;
-    /** Cancel a running solo session. Kill all agents and clean up worktrees. */
-    cancel(soloId: string): Promise<void>;
-    /**
-     * Select a winner and adopt their worktree changes into the workspace.
-     *
-     * Racers never commit on their `solo/*` branch, so the old `git merge --no-ff` here was a no-op
-     * ("Already up to date") and the follow-up cleanup then deleted every uncommitted产物. Adoption
-     * now COPIES the winner's staged/untracked changes back (same materialize path Product mode uses)
-     * and only cleans up after the copy succeeded — a materialize failure keeps all worktrees intact.
-     */
-    select(params: SoloSelectParams): Promise<string>;
-    /** Delete a solo session, killing agents and cleaning up worktrees if still active. */
-    delete(soloId: string): Promise<void>;
-    /**
-     * Pick a ready agent that is NOT racing to act as an independent judge (小智优先). Returns a
-     * synthetic member on the same supervised delegate rail: unique seq (= agents.length) keeps its
-     * memberKey distinct, cwd = the project workspace (the judge only reads the prompt; evaluation
-     * turns are stream-suppressed and its memberId is unknown to getMemberContext, so nothing leaks
-     * into competitor columns). Best effort — any failure falls back to a participant judge.
-     */
-    private resolveExternalJudge;
-    /**
-     * Build an evaluation prompt and send to the user-chosen evaluator agent.
-     * Returns evaluation result.
-     */
-    private evaluate;
-    private parseEvaluationResponse;
-    private cleanupWorktrees;
-}

package/dist/types/orchestration/solo-persistence.d.ts

@@ -1,47 +0,0 @@
-/**
- * Solo persistence facade over the Gateway-owned RunStateStore.
- */
-import type { SoloAgentState, SoloEvaluation, SoloSpec, SoloState } from "../protocol/wire/acp-agent-management.js";
-import { type HostRunStateAuthority } from "./run-state-host-authority.js";
-export interface PersistedSoloState {
-    soloId: string;
-    projectId: string;
-    state: SoloState;
-    task: string;
-    cwd: string;
-    gitRoot: string;
-    agents: Array<{
-        agentId: string;
-        displayId?: string;
-        memberId: string;
-        /** Stable delegate handle sequence that distinguishes duplicate agent IDs. */
-        seq: number;
-        worktreePath: string;
-        worktreeBranch: string;
-        state: SoloAgentState;
-        resultText?: string;
-        diff?: string;
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-        error?: string;
-        turns?: Array<{
-            role: "user" | "agent";
-            content: string;
-            timestamp: number;
-        }>;
-    }>;
-    evaluation?: SoloEvaluation;
-    spec?: SoloSpec;
-    createdAt: number;
-}
-export interface SoloPersistenceOptions {
-    authority?: HostRunStateAuthority;
-}
-/** Save the latest Solo snapshot through Gateway authority. */
-export declare function saveSoloState(state: PersistedSoloState, options?: SoloPersistenceOptions): Promise<void>;
-/** Load the latest Solo snapshot from Gateway authority. */
-export declare function loadSoloState(soloId: string, options?: SoloPersistenceOptions): Promise<PersistedSoloState | undefined>;
-/** Delete a Solo run through Gateway authority. */
-export declare function deleteSoloState(soloId: string, options?: SoloPersistenceOptions): Promise<boolean>;

package/dist/types/orchestration/solo-spec-builder.d.ts

@@ -1,58 +0,0 @@
-/**
- * Solo Spec Builder — 小智(qlogicagent)主持的「一轮澄清 + 轻量 spec」过程。
- *
- * 路径选择:走 runForkedAgent(进程内推理 agent,同 team-delegate/dream),而非 solo 竞赛的
- * processManager.spawn(ACP 子进程)。理由:spec 阶段是交互式推理(分析→ask-user 澄清→产 spec),
- * 不改文件、不需 worktree,且需要 ask-user 交互 —— 这正是 runForkedAgent 的场景。
- *
- * 本模块是纯编排:askUser 后端 + ask_user 工具定义由调用方(Cut3 RPC handler)注入,
- * 这样模块本身不依赖全局 ask-user 回调或 toolCatalog。
- */
-import type { ForkedAgentRunnerFactory } from "../runtime/ports/agent-execution-contracts.js";
-import type { LLMTransport } from "../runtime/ports/index.js";
-import type { ToolDefinition, AgentLogger } from "../agent/types.js";
-import type { SoloSpec } from "../protocol/wire/acp-agent-management.js";
-import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
-/** R3 多轮对话式 spec 的单轮入参。history 含到本轮为止的完整对话(末条为用户最新消息)。 */
-export interface SpecChatDeps {
-    rawTask: string;
-    history: {
-        role: "user" | "assistant";
-        content: string;
-    }[];
-    transport: LLMTransport;
-    apiKey: string;
-    model: string;
-    createAgentRunner: ForkedAgentRunnerFactory;
-    askUserToolDef: ToolDefinition;
-    askUser: (questions: AskUserQuestion[], signal?: AbortSignal) => Promise<Record<string, string> | null>;
-    log: AgentLogger;
-    parentSignal?: AbortSignal;
-    /** Per-phase progress for the UI. A round is a blocking RPC that otherwise streams nothing back, so
-     *  the handler relays these labels (solo.specProgress) to replace the frozen "思考中" with the real
-     *  phase (分析 → 确认 → 拟定). Best-effort: never throws into the round. */
-    onPhase?: (phase: string) => void;
-    /** (a) Owner global memory cheat-sheet — the spec moderator must honor standing
-     *  preferences/boundaries (language, style, hard limits) when drafting the spec. */
-    globalMemoryIndex?: string | null;
-    /** 上一轮已形成的规格草稿。多轮打磨必须在它的基础上增量更新——不回传会导致第二轮起模型
-     *  凭对话重写整份规格,用户此前敲定的约束/验收被静默丢弃。 */
-    previousSpec?: SoloSpec | null;
-}
-/** R3 多轮对话式 spec:agent 通过此工具产出/更新结构化规格(类比 plan_mode 的 plan 入参)。 */
-export declare const SET_SPEC_TOOL_NAME = "set_spec";
-export declare const SET_SPEC_TOOL_DEF: ToolDefinition;
-/**
- * R3 单轮对话式 spec(无状态:每轮带全量 history 重跑 forked agent)。受限工具 = ask_user + set_spec,
- * 纯推理不改文件(plan-mode 式)。返回本轮自然语言 reply + 最新 SoloSpec(set_spec 未调时回退解析文本)。
- * 失败(LLM/连接级)会抛 —— 由调用方降级。
- */
-export declare function runSpecChatRound(deps: SpecChatDeps): Promise<{
-    reply: string;
-    spec: SoloSpec;
-}>;
-/** 解析小智的标记块文本 → SoloSpec。带兜底,绝不抛(降级:goal=rawTask、acceptance 可空)。 */
-export declare function parseSpecResponse(text: string, rawTask: string, clarifications?: {
-    question: string;
-    answer: string;
-}[]): SoloSpec;

package/dist/types/orchestration/testing/delegate-test-bridge.d.ts

@@ -1,23 +0,0 @@
-import type { DelegateBridge } from "../delegate-bridge.js";
-interface LegacyTurnFixture {
-    sendTask(memberId: string, prompt: string, options?: {
-        timeout?: number;
-        session?: unknown;
-    }): Promise<unknown>;
-    getUsageTracker?(memberId: string): {
-        getUsage(): {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    } | null;
-    /**
-     * Optional streamed chunks for this turn, replayed through the caller's sink before the result
-     * resolves. The bridge used to drop the sink entirely, so no test could observe which turns stream —
-     * which is how every acceptance verdict reached the leader conversation unnoticed.
-     */
-    streamDeltas?(memberId: string, prompt: string): string[];
-    lifecycleEvents?(memberId: string, prompt: string): Array<Record<string, unknown>>;
-}
-/** Test-only adapter for migrating orchestration fixtures from the retired local spawn lane. */
-export declare function makeDelegateTestBridge(processManager: LegacyTurnFixture): DelegateBridge;
-export {};

package/dist/types/orchestration/testing/host-agent-provider-directory-fixture.d.ts

@@ -1,7 +0,0 @@
-import type { HostAgentProviderState } from "../../host-contract/index.js";
-import type { HostAgentProviderDirectory } from "../../runtime/infra/host-agent-provider-directory.js";
-export interface HostProviderDirectoryFixtureOptions {
-    states?: Readonly<Record<string, HostAgentProviderState | "not_installed">>;
-    diagnostics?: Readonly<Record<string, string>>;
-}
-export declare function makeHostAgentProviderDirectoryFixture(options?: HostProviderDirectoryFixtureOptions): HostAgentProviderDirectory;

package/dist/types/orchestration/testing/run-state-client-double.d.ts

@@ -1,13 +0,0 @@
-/**
- * Test double helper for HostRunStateClient.
- *
- * The RunState client contract is hand-rolled into ~19 inline object literals across the orchestration
- * tests, each cast with `as never`. That cast means TypeScript cannot tell a double from a real client,
- * so adding a method to the contract breaks every one of them at RUNTIME instead of at compile time —
- * which is exactly what happened when `openWithCheckpoint` was introduced.
- *
- * This wrapper derives the atomic method from whatever `open`/`checkpoint` the double already provides,
- * so existing spies and their assertions keep working unchanged: `openWithCheckpoint` still routes
- * through the double's own `checkpoint` spy, preserving every "checkpoint was called with X" assertion.
- */
-export declare function runStateClientDouble<T extends Record<string, unknown>>(partial: T): never;

package/dist/types/orchestration/workflow/budget-permission-gate.d.ts

@@ -1,94 +0,0 @@
-/**
- * Budget + permission ExecutionGate — the engine half of plan D15 ("无人值守触发须过 budget+权限闸门")
- * and the M2 acceptance "触发式运行受 budget+权限闸门拦截".
- *
- * A workflow run is either ATTENDED (trigger "manual": a human is present and authorizes
- * interactively) or UNATTENDED (trigger "schedule" / "im-message" / "webhook": fired by the
- * trigger layer with nobody watching). This gate enforces two independent guarantees on every
- * node, before it executes:
- *
- *   1. Permission (security, HARD fail-loud) — an unattended run may only execute side-effecting
- *      ("sensitive") node kinds that were EXPLICITLY authorized via `allowUnattendedKinds`. A
- *      sensitive kind that was not pre-authorized throws `WorkflowPermissionDenied` and halts the
- *      run (status "failed"). Pure / control-flow kinds (set/if/loop/merge/passthrough/trigger)
- *      are always allowed. Manual runs skip permission entirely (the user is the authorization).
- *   2. Budget (resumable pause) — every node must pass the per-run budget (D15 "每轮过 budget"):
- *      a hard cap on node executions and an optional wall-clock cap. Exceeding either throws
- *      `WorkflowBudgetExceeded`, which extends the runtime's pause signal, so the run SUSPENDS
- *      with its cache intact (raise the budget, then resume) rather than failing — mirroring the
- *      existing ProductBudgetTracker "exceeded → pause" semantics.
- *
- * Pure and deterministic: no I/O, an injectable clock. fail-loud construction: a non-positive
- * `maxNodeExecutions` (or non-positive `maxDurationMs`) throws — a budget with no ceiling is a
- * silent way to disable the gate, which D15 forbids.
- */
-import { WorkflowPauseSignal, type ExecutionGate } from "./workflow-runtime.js";
-/** The trigger kinds that can start a run. Single source of the union (consumed by the controller). */
-export type WorkflowTriggerKind = "manual" | "schedule" | "im-message" | "webhook" | "intent" | "form";
-/**
- * Node kinds that reach the outside world (network calls, channel sends, Agent/Action side
- * effects). These require explicit authorization to run unattended. Control / data-shaping kinds
- * (set / if / loop / merge / passthrough / trigger) are NOT here — they cannot escape the engine.
- */
-export declare const SENSITIVE_KINDS: ReadonlySet<string>;
-/**
- * The distinct sensitive (side-effecting) kinds present among these node kinds — i.e. the
- * capabilities a workflow will need authorized to run unattended. Pure; drives upfront disclosure at
- * ACTIVATION so the user authorizes these knowingly, instead of the first unattended run hard-failing
- * at the gate (the old surprise: "activated fine, then the 3am schedule died at a channel send").
- */
-export declare function requiredUnattendedPermissions(nodeKinds: Iterable<string>): string[];
-/** Required unattended permissions NOT yet granted — exactly what activation should ask to authorize. */
-export declare function missingUnattendedAuthorizations(nodeKinds: Iterable<string>, granted: readonly string[] | undefined): string[];
-/** Hard, non-resumable denial: an unauthorized side-effecting kind under an unattended trigger. */
-export declare class WorkflowPermissionDenied extends Error {
-    readonly nodeId: string;
-    readonly kind: string;
-    readonly trigger: WorkflowTriggerKind;
-    constructor(nodeId: string, kind: string, trigger: WorkflowTriggerKind);
-}
-/**
- * Budget ceiling reached. Extends WorkflowPauseSignal so the runtime treats it as a graceful,
- * resumable suspension (cache retained) rather than a failure — the caller raises the budget and
- * resumes, and already-completed nodes hit cache.
- */
-export declare class WorkflowBudgetExceeded extends WorkflowPauseSignal {
-    readonly reason: "executions" | "duration";
-    readonly limit: number;
-    constructor(atNodeId: string, reason: "executions" | "duration", limit: number);
-}
-export interface BudgetPermissionGateOptions {
-    /** Trigger kind of THIS run. "manual" = attended (permission skipped); others = unattended. */
-    trigger: WorkflowTriggerKind;
-    /** Hard cap on node executions per run (D15 loop hard-cap is separate, in the scheduler). */
-    maxNodeExecutions: number;
-    /** Optional wall-clock cap in ms; the run pauses once elapsed reaches it. */
-    maxDurationMs?: number;
-    /** Sensitive kinds an UNATTENDED run is allowed to execute. Ignored for manual runs. */
-    allowUnattendedKinds?: readonly string[];
-    /** Injectable clock (ms epoch) for deterministic tests. */
-    now?: () => number;
-}
-export declare class BudgetPermissionGate implements ExecutionGate {
-    private readonly trigger;
-    private maxNodeExecutions;
-    private maxDurationMs?;
-    private readonly allow;
-    private readonly now;
-    private executions;
-    private startedAt;
-    constructor(opts: BudgetPermissionGateOptions);
-    private get unattended();
-    /** Invoked by the runtime before each node executes. Throws to deny (hard) or pause (budget). */
-    check(nodeId: string, kind: string): void;
-    /**
-     * Raise the remaining allowance so a budget-paused run can resume (D15 "抬预算后 resume").
-     * Deltas are ADDED to the current ceilings. fail-loud: a non-positive delta is rejected, and
-     * extending duration is only valid when a duration cap exists (extending an absent cap is a
-     * silent no-op the caller likely did not intend).
-     */
-    extend(delta: {
-        executions?: number;
-        durationMs?: number;
-    }): void;
-}

package/dist/types/orchestration/workflow/builtin-capabilities.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityEntry } from "./capability-catalog.js";
-/** Fresh copies prevent Host/UI consumers from mutating the shared contract. */
-export declare function builtinWorkflowCapabilities(): CapabilityEntry[];

package/dist/types/orchestration/workflow/builtin-executors.d.ts

@@ -1,18 +0,0 @@
-/**
- * Built-in deterministic NodeExecutors (M2).
- *
- * These are REAL node implementations (not mocks): pure data transforms used by automation
- * workflows. Host-backed kinds (agent/tool/http/mcp/channel) are injected separately so the
- * engine stays a pure executor (plan D12/D13).
- *
- * Note: "loop" is NOT here — loop control is owned by the runtime (DagScheduler.decideLoop),
- * not a user executor.
- */
-import type { NodeExecutor } from "./node-schema.js";
-/**
- * Params the runtime must NOT pre-resolve at node level (D34): these carry per-item
- * expressions ($json = each item) that the executor evaluates itself — same restricted
- * language, same evaluator, just per-item invocation.
- */
-export declare const RAW_PARAM_KEYS: Record<string, readonly string[]>;
-export declare const builtinExecutors: Record<string, NodeExecutor>;

package/dist/types/orchestration/workflow/capability-catalog.d.ts

@@ -1,72 +0,0 @@
-/**
- * Canonical Workflow capability-catalog helpers. Runtime owns and injects the exact catalog;
- * qlogicagent only renders and validates that snapshot for Workflow Chat.
- */
-export type CapabilityCategory = "agent" | "action" | "mcp" | "memory" | "channel" | "control";
-export interface CapabilityEntry {
-    category: CapabilityCategory;
-    kind: string;
-    /** Concrete Agent, MCP plugin/tool, memory, channel, or control reference. */
-    id: string;
-    label: string;
-    description?: string;
-    paramsSchema?: Record<string, unknown>;
-    paramsTemplate?: Record<string, unknown>;
-    pluginId?: string;
-    toolName?: string;
-    server?: string;
-    tool?: string;
-    /** Machine-readable planning hints owned by Runtime, not prose invented by the Agent. */
-    useWhen?: string[];
-    avoidWhen?: string[];
-    keywords?: string[];
-    inputSchema?: Record<string, unknown>;
-    outputSchema?: Record<string, unknown>;
-    inputPorts?: Array<{
-        name: string;
-        type: string;
-        required?: boolean;
-    }>;
-    outputPorts?: Array<{
-        name: string;
-        type: string;
-    }>;
-    requiredParams?: string[];
-    sideEffectLevel?: "none" | "local" | "external";
-    permissionHints?: string[];
-    constraints?: string[];
-    examples?: Array<{
-        intent: string;
-        params?: Record<string, unknown>;
-    }>;
-}
-/** Render the Host-owned catalog for the AI graph builder prompt. */
-export declare function renderCatalogForPrompt(entries: CapabilityEntry[], perCategoryCap?: number): string;
-/**
- * Select a compact, deterministic capability working set before the Agent turn.
- * The full catalog remains available through list_capabilities for long-tail discovery.
- */
-export declare function selectRelevantCapabilities(entries: CapabilityEntry[], intent: string, options?: {
-    limit?: number;
-    preferredIds?: string[];
-}): CapabilityEntry[];
-/** Extract canonical references for anti-hallucination validation. */
-export declare function collectCapabilityRefs(def: {
-    nodes: {
-        id: string;
-        kind: string;
-        params?: Record<string, unknown>;
-    }[];
-}): {
-    category: CapabilityCategory;
-    ref: string;
-    nodeId: string;
-}[];
-/** Validate canonical references against the Host-owned catalog. */
-export declare function validateCapabilityRefs(def: {
-    nodes: {
-        id: string;
-        kind: string;
-        params?: Record<string, unknown>;
-    }[];
-}, entries: CapabilityEntry[]): string[];

package/dist/types/orchestration/workflow/cron-schedule.d.ts

@@ -1,36 +0,0 @@
-/**
- * Deterministic cron schedule computation (plan M3 trigger layer).
- *
- * `validateCron` (trigger-validation.ts) guarantees a stored schedule is structurally valid; this
- * module turns a validated cron string into a concrete "next fire time" so the in-process
- * WorkflowScheduler can arm a timer. Pure, side-effect-free, and deterministic for an explicit
- * IANA timezone. Legacy callers that omit a timezone retain UTC semantics.
- *
- * Grammar matches validateCron exactly: 5-field (min hour dom month dow) or 6-field (+ leading
- * seconds); each field is a comma-list of star / star-step / value / range / stepped-range, with
- * 3-letter month and day-of-week names, and dow accepting both 0 and 7 for Sunday.
- */
-export interface ParsedCron {
-    hasSeconds: boolean;
-    seconds: Set<number>;
-    minutes: Set<number>;
-    hours: Set<number>;
-    /** days-of-month, 1-31 */
-    doms: Set<number>;
-    /** months, 1-12 */
-    months: Set<number>;
-    /** days-of-week, 0-6 (Sunday=0; 7 is normalized to 0) */
-    dows: Set<number>;
-    /** true ⇔ the day-of-month field is restricted (not "*") */
-    domRestricted: boolean;
-    /** true ⇔ the day-of-week field is restricted (not "*") */
-    dowRestricted: boolean;
-}
-/** Parse a validated cron string into expanded numeric sets. Throws on malformed input (fail-loud). */
-export declare function parseCron(cron: string): ParsedCron;
-/**
- * The next instant strictly after `afterMs` (UTC epoch ms) that matches `cron`. Throws if no match
- * exists within a ~5-year horizon (e.g. an impossible date like "0 0 30 2 *"). Deterministic: the
- * same (cron, afterMs) always returns the same value.
- */
-export declare function nextCronTime(cron: string, afterMs: number, timezone?: string): number;

package/dist/types/orchestration/workflow/data-item.d.ts

@@ -1,39 +0,0 @@
-/**
- * Workflow data envelope.
- *
- * Control/data separation: DagScheduler manages control (ready/skip/loop/ports) and
- * never touches these values. The runtime data-routing layer carries DataItem[] along
- * data edges; NodeExecutors consume/produce them.
- *
- * Media travels by-ref (BinaryRef → content-addressed blob store), keeping the envelope
- * small and hash-cacheable.
- */
-/** A content-addressed reference to a large binary (image/video/audio), never inlined into json. */
-export interface BinaryRef {
-    /** Pointer into the engine-managed blob store; content-addressed hash. */
-    ref: string;
-    mimeType: string;
-    size: number;
-    fileName?: string;
-    meta?: Record<string, unknown>;
-}
-/** A single unit of data flowing through a port. Most nodes emit one item per port. */
-export interface DataItem {
-    /** Structured data — what expressions reference. */
-    json: Record<string, unknown>;
-    /** Large binaries by reference; kept out of json. */
-    binary?: Record<string, BinaryRef>;
-}
-/** Per-port payload: every port carries an array of items (supports fan-out / batching). */
-export type PortMap = Record<string, DataItem[]>;
-/** Convenience: wrap a plain object into a single-item DataItem. */
-export declare function item(json: Record<string, unknown>, binary?: Record<string, BinaryRef>): DataItem;
-/** Convenience: a single-item port map on the given port (default "default"). */
-export declare function singlePort(json: Record<string, unknown>, port?: string): PortMap;
-/**
- * Stable content signature of a port map, for the run-from-node cache key (§A5).
- * Binary participates via its content-addressed ref (not its bytes).
- */
-export declare function signaturePortMap(ports: PortMap): string;
-/** Deterministic JSON stringify with sorted object keys (arrays keep order). */
-export declare function stableStringify(value: unknown): string;