qlogicagent 2.15.10 → 2.16.1

package/dist/types/orchestration/dag-scheduler.d.ts

@@ -31,6 +31,9 @@ export interface Node {
     error?: string;
     startedAt?: number;
     completedAt?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    changedFiles?: string[];
     runIndex: number;
     maxIterations?: number;
     iteration?: number;
@@ -83,6 +86,9 @@ export declare class DagScheduler {
     markCompleted(id: string, out: {
         output?: unknown;
         firedPorts?: string[];
+        inputTokens?: number;
+        outputTokens?: number;
+        changedFiles?: string[];
     }): void;
     markFailed(id: string, error: string): void;
     markPaused(id: string): void;
@@ -108,6 +114,15 @@ export declare class DagScheduler {
      * Reset a failed node to pending. Optionally patches params (e.g. revised prompt).
      */
     retryNode(id: string, paramsPatch?: Record<string, unknown>): void;
+    /**
+     * Reset a completed/failed node AND all its transitive descendants back to pending for replay
+     * (CrewAI Crew.replay(task_id) parity), clearing their outputs. Ancestors are left untouched so
+     * their completed outputs continue feeding downstream task-context (getUpstreamOutputs) — replay
+     * re-runs the subtree while reusing upstream results. Pure state mutation: no scheduling.
+     *
+     * Returns the ids that were reset (the node + every descendant).
+     */
+    resetForReplay(id: string): string[];
     /** Merge patch into node.params. Node must be pending. */
     updateNodeParams(id: string, patch: Record<string, unknown>): void;
     /** Add an explicit edge. Validates no cycle. Validates ports exist on source. */
@@ -120,6 +135,15 @@ export declare class DagScheduler {
      * Missing fields use defaults.
      */
     restore(data: SerializedNode[]): void;
+    /**
+     * Returns the completed output of each direct dependency of this node.
+     * Used by Product orchestration to inject upstream task results into downstream prompts
+     * (CrewAI Task.context parity).
+     */
+    getUpstreamOutputs(id: string): {
+        taskId: string;
+        output: string;
+    }[];
     /** §3.1 edge predicate: source completed AND this port fired. */
     private edgeSatisfied;
     /** An edge is "dead" if the source is skipped, OR source completed but did NOT fire this port. */
@@ -161,6 +185,9 @@ export interface SerializedNode {
     error?: string;
     startedAt?: number;
     completedAt?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    changedFiles?: string[];
     runIndex: number;
     maxIterations?: number;
     iteration?: number;

package/dist/types/orchestration/product-budget.d.ts

@@ -20,6 +20,8 @@ export declare class ProductBudgetTracker {
     private maxTotalTokens?;
     private maxDuration?;
     private usedTokens;
+    private inputTokens;
+    private outputTokens;
     private startedAt;
     private warningEmitted;
     constructor(budget?: {
@@ -41,16 +43,20 @@ export declare class ProductBudgetTracker {
      * - "exceeded": over 100%, should pause
      */
     check(): BudgetCheck;
-    /** Restore from persisted budget data. */
+    /** Restore from persisted budget data. (input/output optional for back-compat with older snapshots.) */
     restore(data: {
         usedTokens: number;
         startedAt: number;
         warningEmitted: boolean;
+        inputTokens?: number;
+        outputTokens?: number;
     }): void;
     /** Serialize for persistence. */
     serialize(): {
         usedTokens: number;
         startedAt: number;
         warningEmitted: boolean;
+        inputTokens: number;
+        outputTokens: number;
     };
 }

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

@@ -7,6 +7,7 @@
 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";
+import type { PlanningSession } from "./product-planner.js";
 export interface PersistedProductState {
     productId: string;
     name: string;
@@ -23,6 +24,12 @@ export interface PersistedProductState {
     };
     createdAt: string;
     lastCheckpointAt: string;
+    /**
+     * Snapshot of the leader's multi-turn planning dialogue, so the leader regains its planning
+     * context after a resume (today this is in-process only and lost on restart). JSON-safe:
+     * PlanningSession is strings / arrays / plain objects (no functions, dates, or class instances).
+     */
+    leaderDialogue?: PlanningSession;
 }
 export interface ProductPersistenceOptions {
     pathService?: PathService;
@@ -33,3 +40,27 @@ export declare function saveProductState(state: PersistedProductState, cwd?: str
 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[]>;
+/**
+ * Save a full state snapshot into the checkpoints history directory.
+ * Uses `state.lastCheckpointAt` as the logical id (must be set before calling).
+ * Prunes old snapshots to keep at most MAX_CHECKPOINT_SNAPSHOTS entries.
+ */
+export declare function saveProductCheckpointSnapshot(state: PersistedProductState, cwd?: string, options?: ProductPersistenceOptions): Promise<void>;
+/**
+ * Load a specific checkpoint snapshot by its original ISO timestamp.
+ * Returns undefined if the snapshot does not exist.
+ */
+export declare function loadProductCheckpointSnapshot(productId: string, timestamp: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
+/**
+ * List all checkpoint timestamps for a product, sorted ascending (oldest first).
+ * Reads each snapshot file to recover the original ISO timestamp from state.lastCheckpointAt.
+ * Returns an empty array if the checkpoints directory does not exist.
+ */
+export declare function listProductCheckpointTimestamps(productId: string, cwd?: string, options?: ProductPersistenceOptions): Promise<string[]>;
+/**
+ * Restore a specific checkpoint as the latest product state.
+ * Loads the snapshot for `timestamp`, overwrites product-state.json with it,
+ * and returns the restored state. Returns undefined if the snapshot is not found
+ * (caller should fall back to the existing latest state).
+ */
+export declare function restoreProductCheckpoint(productId: string, timestamp: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;

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

@@ -47,9 +47,28 @@ export interface PlanningSession {
         maxTotalTokens?: number;
         maxDuration?: number;
     };
+    /**
+     * User-supplied allow-list of agent ids the leader may assign tasks to (planning AND execution-phase
+     * reassignment). Persisted AS-IS so the execution phase reuses the SAME constraint and a failure-driven
+     * reassign cannot pull in a non-participating agent. PRESENCE-based (must survive uncollapsed end to
+     * end): undefined → all ready agents; `[]` → ONLY the leader 小智 (user deselected every worker);
+     * `[ids]` → those + leader. See buildAgentRoster for the always-include-leader rule.
+     */
+    allowedAgents?: string[];
     createdAt: string;
     /** Last checkpoint timestamp for durable execution. */
     lastCheckpoint?: string;
+    /** A leader turn is currently running (planning is async/fire-and-forget) — block concurrent turns. */
+    turnInFlight?: boolean;
+}
+export interface ProductPlanAskQuestion {
+    question: string;
+    header: string;
+    options?: Array<{
+        label: string;
+        description?: string;
+    }>;
+    multiSelect?: boolean;
 }
 export interface PlannerCallbacks {
     log?: {
@@ -64,8 +83,17 @@ export interface PlannerCallbacks {
     onPlanningDelta?: (productId: string, text: string) => void;
     /** Leader sent a message to user (multi-turn). */
     onLeaderMessage?: (productId: string, message: string) => void;
+    /** Leader asked a structured clarifying question (turn-boundary); client renders an ask panel. */
+    onLeaderAsk?: (productId: string, askId: string, questions: ProductPlanAskQuestion[]) => void;
     /** Leader dynamically mutated the DAG during execution. */
     onDagMutated?: (productId: string, mutation: DagMutation) => void;
+    /** Live DAG progress for the execution-phase leader (filled by the orchestrator). */
+    getProgress?: (productId: string) => {
+        total: number;
+        completed: number;
+        running: number;
+        failed: number;
+    };
 }
 /** Describes a DAG mutation performed by the leader. */
 export interface DagMutation {
@@ -88,6 +116,27 @@ export declare class ProductPlanner {
         productId: string;
         plan: ProductPlan;
     }>;
+    /**
+     * Run one leader planning turn DETACHED from the RPC. Tokens stream live via product.planningDelta
+     * (the member turn.delta relay in product-coordinator); on completion this fires onPlanReady (parsed
+     * a structured plan), onLeaderAsk (a clarifying question), or onLeaderMessage (a non-plan reply).
+     * Never rejects into the caller — planning is fire-and-forget. Concurrent turns on the same session
+     * are blocked (a second prompt would cancel the in-flight one — the source of earlier "cancelled"
+     * turns) — EXCEPT the internal single-shot reprompt (isReprompt=true), which is allowed to run while
+     * turnInFlight is held by its parent turn and is itself guarded against further recursion.
+     */
+    private runLeaderTurn;
+    /**
+     * Route one leader response: plan → onPlanReady, ask → onLeaderAsk, else free-text → onLeaderMessage.
+     *
+     * Crucially, when the response LOOKS LIKE a plan (has a ```json fence or a "tasks" key) but fails to
+     * parse as one — the embedded-fence / unescaped-quote failure modes — we do NOT dump the raw JSON into
+     * the chat bubble. We re-prompt the leader EXACTLY ONCE with a strict "valid JSON only" instruction
+     * (guarded by `isReprompt` so it can't loop), and if that ALSO fails we emit a clean, user-facing
+     * fallback message instead of the raw JSON. A response only reaches onLeaderMessage verbatim when it
+     * does NOT look like a plan (genuine clarification / free-text).
+     */
+    private routeLeaderResponse;
     /**
      * Send a user message to the leader (works in planning and execution phases).
      * Returns the leader's response and optionally a finalized plan.
@@ -114,6 +163,21 @@ export declare class ProductPlanner {
     cancel(productId: string): Promise<void>;
     /** List active sessions. */
     listSessions(): PlanningSession[];
+    /**
+     * Ask the leader to judge whether a worker task's output satisfies its acceptanceCriteria.
+     * Returns { pass: true } immediately when there is no leader session (fail-open).
+     * If the response cannot be parsed at all, defaults to { pass: true } (lenient, like solo.specJudge).
+     */
+    reviewTaskOutput(productId: string, review: {
+        taskId: string;
+        instruction: string;
+        acceptanceCriteria: string;
+        output: string;
+        changedFiles?: string[];
+    }): Promise<{
+        pass: boolean;
+        feedback?: string;
+    }>;
     /**
      * Ask leader to evaluate execution state and propose DAG mutations.
      * Called by ProductOrchestrator when tasks fail or progress stalls.
@@ -141,6 +205,65 @@ export declare class ProductPlanner {
     private handlePlanningMessage;
     private handleExecutionMessage;
     private sendToLeader;
+    /**
+     * Extract a JSON object from the leader's reply. The leader (an LLM) formats the block
+     * inconsistently: ```json on its own line, ```json with the object inline, no language tag, or no
+     * fence at all. A non-greedy fence regex (`/```(?:json)?\s*([\s\S]*?)```/`) is fatally fragile: when a
+     * task/module prompt STRING embeds its own code fence (e.g. a ```bash example inside a task prompt),
+     * the non-greedy match stops at that EMBEDDED closing ```, truncating the block BEFORE the "tasks"
+     * key → a shape-valid-but-incomplete object → plan lost → raw JSON leaks into the chat bubble.
+     *
+     * Instead, scan for a balanced JSON object with string-awareness:
+     *   - Pick a start index: the first `{` AT OR AFTER a ```json (or bare ```) fence opener if present,
+     *     else the first `{` anywhere.
+     *   - From that `{`, walk forward tracking brace depth AND JSON string state (an unescaped `"` toggles
+     *     inString; a `\` inside a string escapes the next char). Count `{`/`}` only when NOT inString.
+     *     Backticks/braces inside string values are thus ignored — embedded ```bash fences can't truncate.
+     *   - When depth returns to 0, return the balanced `{`…`}` substring (trimmed).
+     *   - If no balanced close is found, fall back to first-`{`…last-`}` (jsonrepair still gets a shot).
+     *   - Return null if there is no `{` at all.
+     */
+    private extractJsonBlock;
+    /**
+     * Parse a JSON block that an LLM emitted. LLMs (DeepSeek especially, on Chinese content) routinely
+     * produce JSON with unescaped double quotes inside string values (e.g. 默认有"销售收入""其他收入"),
+     * trailing commas, etc. — strictly invalid, so JSON.parse throws and the whole plan is lost. Fall back
+     * to jsonrepair, which fixes these common LLM mistakes heuristically. Returns null only if even the
+     * repaired text won't parse.
+     */
+    private parseJsonLenient;
+    /**
+     * Build a canonicalizer that maps a leader-written agent identifier (which may be a display NAME like
+     * "小智"/"Claude" OR a canonical catalog id like "qlogicagent"/"claude") to the canonical catalog id.
+     *
+     * WHY: the leader prompt asks for `instances[].agentId` = "花名册里的 id", but leaders routinely emit
+     * the display NAME instead (e.g. agentId:"小智"). Downstream — the confirm pre-check
+     * (isAgentReady) and dispatch (buildExternalDescriptor) — both require a CANONICAL id; a name like
+     * "小智" makes isAgentReady fail (the qlogicagent always-ready short-circuit only matches the id, not
+     * the name) → leader-only Product wrongly blocked. Canonicalizing at parse time guarantees
+     * instances[].agentId is a catalog id regardless of what the leader wrote.
+     *
+     * The map is keyed by BOTH lowercased `id` AND lowercased `name` → canonical `id`, plus the explicit
+     * leader aliases "小智"→"qlogicagent" and "self"→"qlogicagent". Matching is EXACT (trim+lowercase) on
+     * id-or-name only — no partial/fuzzy matching, to avoid mis-mapping one agent onto another.
+     */
+    private buildAgentIdResolver;
+    /**
+     * Normalize every `task.assignee` so it ALWAYS equals an existing `instance.name` (the canonical
+     * convention the execution dispatch keys on — see agent-instance.ts `instances.find(i => i.name === …)`).
+     *
+     * Mutates `instances`/`tasks` in place. For each task:
+     *  - assignee already === some instance.name → keep.
+     *  - else assignee resolves to an agentId that some instance carries → repoint assignee to THAT
+     *    instance's name (pick the first matching instance, preferring a non-leader/worker role when the
+     *    same agentId backs several instances — leaders usually shouldn't also be doing leaf work).
+     *  - else (assignee references an agent with no instance) → append a fresh worker instance
+     *    `{ name: assignee, agentId: resolveAgentId(assignee) ?? assignee, role: "worker" }` and keep
+     *    assignee = that new name (now it matches).
+     * Blank assignees are left untouched (confirm-time validation surfaces them).
+     */
+    private normalizeAssigneesToInstanceName;
     private tryParsePlan;
+    private tryParseAsk;
     private parseDagMutations;
 }

package/dist/types/orchestration/product-run-coordinator.d.ts

@@ -1,6 +1,6 @@
 import type { ProductConfirmParams, ProductPlan } from "../protocol/wire/acp-agent-management.js";
 import type { ProductOrchestrator } from "./agent-instance.js";
-import type { DagMutation, ProductPlanner } from "./product-planner.js";
+import type { DagMutation, PlanningSession, ProductPlanner } from "./product-planner.js";
 export interface ProductLeaderCoordinator {
     consultLeader(productId: string, context: {
         progress: {
@@ -14,6 +14,22 @@ export interface ProductLeaderCoordinator {
             error: string;
         }>;
     }): Promise<DagMutation[]>;
+    reviewTaskOutput(productId: string, review: {
+        taskId: string;
+        instruction: string;
+        acceptanceCriteria: string;
+        output: string;
+        /** Relative paths the worker created/changed in its worktree — evidence the text-only judge
+         *  cannot otherwise see. Lets the judge confirm the expected artifacts exist (lenient judging). */
+        changedFiles?: string[];
+    }): Promise<{
+        pass: boolean;
+        feedback?: string;
+    }>;
+    /** Snapshot the leader's PlanningSession for checkpoint persistence (durable execution). */
+    serializeSession(productId: string): PlanningSession | null;
+    /** Restore the leader's PlanningSession from a checkpoint (crash/resume recovery). */
+    restoreSession(data: PlanningSession): void;
 }
 export declare class ProductRunCoordinator {
     private planner;

package/dist/types/orchestration/product-worktree.d.ts

@@ -6,6 +6,9 @@ export declare function findGitRoot(cwd: string): Promise<string | null>;
 /** Create an isolated git worktree. Returns the worktree path. */
 export declare function createWorktree(gitRoot: string, name: string, baseBranch?: string): Promise<string>;
 export declare function getWorktreeDiff(worktreePath: string): Promise<string>;
+/** List the relative paths of files changed in a worktree (tracked diff vs HEAD + untracked).
+ *  Used to surface "produced files" on a Product task before the worktree is torn down. */
+export declare function listWorktreeChangedFiles(worktreePath: string): Promise<string[]>;
 /** Copy the changed files from a task worktree back into the product workspace. */
 export declare function materializeWorktreeChanges(worktreePath: string, targetRoot: string): Promise<void>;
 /** Remove a git worktree. */

package/dist/types/orchestration/skill-improvement.d.ts

@@ -10,6 +10,8 @@
  * - Cooldown: prevents rapid-fire creation within a session
  */
 import { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL } from "../runtime/config/tunable-defaults.js";
+import type { SkillInstruction } from "../contracts/turn-event.js";
+export type { SkillCreateInstruction, SkillImproveInstruction, SkillInstruction, } from "../contracts/turn-event.js";
 export { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL };
 export interface SkillTurnResult {
     ok: boolean;
@@ -26,25 +28,6 @@ export interface SkillTurnResult {
     /** Skill name if an existing skill was used */
     existingSkillName?: string | null;
 }
-export interface SkillCreateInstruction {
-    type: "skill.create";
-    /** Suggested skill name derived from tool usage pattern */
-    suggestedName: string;
-    /** Short description of what the skill does */
-    description: string;
-    /** Tool names involved */
-    tools: string[];
-    /** Number of orchestration steps */
-    stepCount: number;
-}
-export interface SkillImproveInstruction {
-    type: "skill.improve";
-    /** Existing skill to improve */
-    skillName: string;
-    /** Reason for improvement */
-    reason: string;
-}
-export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
 /**
  * Reset cooldown state (for testing).
  */

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

@@ -80,6 +80,16 @@ export declare class SoloEvaluator {
      * Creates worktrees, spawns agents in parallel, waits for completion, then evaluates.
      */
     start(params: SoloStartParams): Promise<string>;
+    /**
+     * 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.
+     */
+    private ensureAgentRunning;
     /**
      * Send a follow-up message to a specific agent within a solo session.
      * Agent must be in "idle" or "completed" state.

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

@@ -28,6 +28,10 @@ export interface SpecChatDeps {
     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;
 }
 /** R3 多轮对话式 spec:agent 通过此工具产出/更新结构化规格(类比 plan_mode 的 plan 入参)。 */
 export declare const SET_SPEC_TOOL_NAME = "set_spec";

package/dist/types/orchestration/workflow/n8n-import.d.ts

@@ -1,41 +1,40 @@
-/**
- * n8n workflow JSON import — read-format-only translator (plan M5 §2.1: "导入 n8n workflow JSON
- * (读格式,不打包其代码)"), deepened for IT-11 (spec D35).
- *
- * Converts an n8n workflow export (its public JSON shape: `nodes` + `connections`) into our own
- * WorkflowDef. This reads n8n's data FORMAT only — it links/embeds NONE of n8n's runtime code, so
- * the SUL licensing concern (plan §2.1 / risk register) does not apply.
- *
- * Error model (IT-11): STRUCTURAL problems (malformed JSON, duplicate/missing node names, dangling
- * connections) stay fail-loud — the graph identity itself is broken, nothing useful survives.
- * SEMANTIC gaps (unmapped node type, inconvertible expression, Code-node JS) DEGRADE EXPLICITLY:
- * the node lands as kind "manual" (its executor throws at run time — never silently passes
- * through), the original n8n type/params are preserved for the human, and every degradation is
- * itemized in the returned ConversionReport. Nothing is silently dropped; no JS is ever executed
- * (D6 hard line — n8n Code nodes are flagged manual, not emulated).
- *
- * Credentials: n8n nodes carry `credentials: {type: {id,name}}` references. The secrets are NOT
- * in the export — we extract them as CredentialRequirement entries (mapped to vault types, D29)
- * so the import UI can walk the user through re-binding.
- */
 import type { WorkflowDef } from "./node-schema.js";
+export interface N8nImportOptions {
+    strictTemplates?: boolean;
+}
 export interface N8nNodeReport {
     id: string;
     n8nType: string;
-    /** converted=faithful; partial=landed but params need attention; manual=placeholder node; skipped=annotation dropped. */
-    outcome: "converted" | "partial" | "manual" | "skipped";
+    outcome: "converted" | "partial" | "manual" | "skipped" | "unsupported";
     notes: string[];
 }
 export interface N8nCredentialRequirement {
     nodeId: string;
     n8nCredentialType: string;
-    /** n8n-side display name of the credential (helps the user recognize which secret to re-create). */
     label?: string;
-    /** Suggested vault credential type (D29). */
     suggestedVaultType: string;
 }
+export interface N8nBindingRequirement {
+    models: Array<{
+        nodeId: string;
+        n8nCredentialType: string;
+        modelPurpose: string;
+        label?: string;
+    }>;
+    agents: Array<{
+        nodeId: string;
+        agentId?: string;
+        fallback: boolean;
+        label?: string;
+    }>;
+    connections: Array<{
+        nodeId: string;
+        n8nCredentialType: string;
+        connectionType: string;
+        label?: string;
+    }>;
+}
 export interface N8nConversionReport {
-    /** full=everything faithful; partial=some degradations; manual=at least one manual placeholder. */
     status: "full" | "partial" | "manual";
     nodes: N8nNodeReport[];
     expressions: {
@@ -48,6 +47,7 @@ export interface N8nConversionReport {
         }>;
     };
     credentials: N8nCredentialRequirement[];
+    bindings: N8nBindingRequirement;
     notes: string[];
 }
 export interface N8nImportResult {
@@ -55,14 +55,8 @@ export interface N8nImportResult {
     def: WorkflowDef;
     report: N8nConversionReport;
 }
-/** Thrown when an n8n workflow is STRUCTURALLY untranslatable. Carries every problem found. */
 export declare class N8nImportError extends Error {
     readonly errors: string[];
     constructor(errors: string[]);
 }
-/**
- * Convert an n8n workflow (a JSON string or already-parsed object) into a WorkflowDef + report.
- * The returned def is NOT yet graph-validated — pass it to `validateWorkflowDef` / a controller
- * write path, which is the single existing invariant gate.
- */
-export declare function convertN8nWorkflow(input: string | unknown, workflowId: string): N8nImportResult;
+export declare function convertN8nWorkflow(input: string | unknown, workflowId: string, opts?: N8nImportOptions): N8nImportResult;

package/dist/types/orchestration/workflow/n8n-template-compat.d.ts

@@ -0,0 +1,5 @@
+export declare const N8N_TEMPLATE_TYPE_MAP: Record<string, string>;
+export declare function isModelCredentialType(type: string): boolean;
+export declare function isAgentKind(kind: string): boolean;
+export declare function modelPurposeForCredential(type: string): string;
+export declare function suggestConnectionType(n8nType: string, credentialType: string): string;

package/dist/types/orchestration/workflow/node-registry.d.ts

@@ -7,12 +7,25 @@
  * engine stays a pure executor (plan D12/D13).
  */
 import type { NodeExecutor } from "./node-schema.js";
+/**
+ * Node kinds whose builtin executor is an import-only stub a host is meant to replace.
+ * installHostExecutors overrides ONLY these when already present; any other
+ * pre-registered kind is kept. Single source of the "rebindable kind" rule.
+ */
+export declare const REBINDABLE_NODE_KINDS: Set<string>;
 export declare class NodeRegistry {
     private executors;
     constructor(includeBuiltins?: boolean);
     register(kind: string, executor: NodeExecutor): void;
     /** Replace an existing executor (e.g. host overrides a built-in). Must already exist. */
     override(kind: string, executor: NodeExecutor): void;
+    /**
+     * Wire host-backed executors — the single source of the host-wiring rule used by the
+     * runtime, the gateway handler, and tests. Absent kinds are registered; an already-present
+     * rebindable kind (agentBinding/modelBinding, whose builtin is an import-only stub) is
+     * overridden; any other already-present kind is kept (caller's pre-registration wins).
+     */
+    installHostExecutors(executors: Record<string, NodeExecutor>): void;
     has(kind: string): boolean;
     get(kind: string): NodeExecutor;
     kinds(): string[];

package/dist/types/orchestration/workflow/node-schema.d.ts

@@ -115,6 +115,8 @@ export interface ExecutorContext {
 export interface ExecutorHost {
     /** Run an agent turn. Returns the agent's structured output as DataItem(s). */
     runAgent(req: AgentHostRequest): Promise<DataItem[]>;
+    /** Run the currently configured workflow/text model. The host resolves provider/API key/model. */
+    runModel?(req: ModelHostRequest): Promise<DataItem[]>;
     /** Invoke a qlogicagent tool by name. */
     invokeTool(req: ToolHostRequest): Promise<DataItem[]>;
     /** Perform an HTTP request (credentials resolved host-side). */
@@ -150,6 +152,14 @@ export interface AgentHostRequest {
     input: DataItem[];
     signal?: AbortSignal;
 }
+export interface ModelHostRequest {
+    prompt: string;
+    modelHint?: string;
+    temperature?: number;
+    maxTokens?: number;
+    input: DataItem[];
+    signal?: AbortSignal;
+}
 export interface ToolHostRequest {
     tool: string;
     args: Record<string, unknown>;

package/dist/types/orchestration/workflow/qla-executor-host.d.ts

@@ -7,7 +7,7 @@
  * callback. Tool invocation goes straight through the single-source-of-truth tool registry
  * (`findTool`). fail-loud everywhere: unknown tool, missing channel host, or any rejection throws.
  */
-import type { RuntimeToolContract } from "../../runtime/ports/index.js";
+import type { LLMTransport, RuntimeToolContract } from "../../runtime/ports/index.js";
 import { type DataItem } from "./data-item.js";
 import type { ExecutorHost, ToolHostRequest, MemoryHostRequest, SubworkflowHostRequest, ApprovalHostRequest, WebhookWaitHostRequest } from "./node-schema.js";
 /** Injected boundary capabilities — supplied by the handler host that owns the real runners. */
@@ -18,6 +18,12 @@ export interface QlaExecutorHostDeps {
         prompt: string;
         signal?: AbortSignal;
     }) => Promise<string>;
+    /** Resolve the owner's configured Settings -> Model text model. */
+    resolveClientForPurpose?: (purpose: "textGeneration") => {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
     /** Invoke an MCP server tool through the real MCP bridge. */
     invokeMcp: (req: {
         server: string;

package/dist/types/protocol/methods.d.ts

@@ -8,7 +8,7 @@
  */
 import type { ChatMessage, LocalizedToolText, ToolCapabilityCategory } from "./wire/chat-types.js";
 import type { AgentDescriptor, AgentConfig, GatewayRpcMethodMap, RpcProjectInfo, RpcProjectType, RpcProjectStatus, SoloStatus, ProductStatus, ProductSummary } from "./wire/index.js";
-import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams } from "./wire/acp-agent-management.js";
+import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams, ProductReplayParams } from "./wire/acp-agent-management.js";
 export interface InitializeParams {
     protocolVersion: string;
     host?: {
@@ -1048,6 +1048,13 @@ export interface RpcMethodMap {
             ok: true;
         };
     };
+    "product.replay": {
+        params: ProductReplayParams;
+        result: {
+            productId: string;
+            ok: true;
+        };
+    };
     "project.create": {
         params: ProjectCreateParams;
         result: ProjectCreateResult;

package/dist/types/protocol/notifications.d.ts

@@ -6,4 +6,4 @@
  * This file re-exports the wire types.
  * Internal consumers import from this file — zero churn.
  */
-export type { AgentSource, AgentsErrorNotification, AgentsStatusNotification, ArtifactType, MediaResultType, MemoryDecayCompletedNotification, MemoryUpdatedNotification, NotificationMethod, NotificationMethodMap, NotificationThreadItem, PermissionRuleUpdatedNotification, PlanInterruptedNotification, PongNotification, ProductBudgetUpdateNotification, ProductBudgetWarningNotification, ProductCheckpointedNotification, ProductCompletedNotification, ProductDagTopologyNotification, ProductPlanFailedNotification, ProductPlanningDeltaNotification, ProductPlanReadyNotification, ProductTaskCompletedNotification, ProductTaskFailedNotification, ProductTaskOutputDeltaNotification, ProductTaskStartedNotification, ProjectArchivedNotification, ProjectCreatedNotification, ProjectDeletedNotification, ProjectRenamedNotification, ProjectSwitchedNotification, ProjectUnarchivedNotification, SessionInfoNotification, SoloAgentDeltaNotification, SoloAgentUsageNotification, SoloEvaluationNotification, SoloProgressNotification, TeamMemberNotification, ToolApprovalRequestNotification, TurnAnnotationsNotification, TurnArtifactNotification, TurnAskUserNotification, TurnDeltaNotification, TurnEndNotification, TurnErrorNotification, TurnExecProgressNotification, TurnHeartbeatNotification, TurnMediaPersistedNotification, TurnMediaProgressNotification, TurnMediaResultNotification, TurnPlanUpdateNotification, TurnReasoningDeltaNotification, TurnRecoveryNotification, TurnSidechainCompletedNotification, TurnSidechainStartedNotification, TurnSkillInstructionNotification, TurnStartNotification, TurnSubagentDeltaNotification, TurnSuggestionsNotification, TurnTaskUpdatedNotification, TurnTodosUpdatedNotification, TurnToolBlockedNotification, TurnToolCallNotification, TurnToolResultNotification, TurnToolUseSummaryNotification, TurnUsageUpdateNotification, WireTokenUsage, } from "./wire/index.js";
+export type { AgentSource, AgentsErrorNotification, AgentsStatusNotification, ArtifactType, MediaResultType, MemoryDecayCompletedNotification, MemoryUpdatedNotification, NotificationMethod, NotificationMethodMap, NotificationThreadItem, PermissionRuleUpdatedNotification, PlanInterruptedNotification, PongNotification, ProductAgentActivityNotification, ProductBudgetUpdateNotification, ProductBudgetWarningNotification, ProductCheckpointedNotification, ProductCompletedNotification, ProductDagTopologyNotification, ProductMembersNotification, ProductPlanFailedNotification, ProductPlanningDeltaNotification, ProductPlanReadyNotification, ProductTaskCompletedNotification, ProductTaskFailedNotification, ProductTaskOutputDeltaNotification, ProductTaskStartedNotification, ProjectArchivedNotification, ProjectCreatedNotification, ProjectDeletedNotification, ProjectRenamedNotification, ProjectSwitchedNotification, ProjectUnarchivedNotification, SessionInfoNotification, SoloAgentDeltaNotification, SoloAgentUsageNotification, SoloEvaluationNotification, SoloProgressNotification, TeamMemberNotification, ToolApprovalRequestNotification, TurnAnnotationsNotification, TurnArtifactNotification, TurnAskUserNotification, TurnDeltaNotification, TurnEndNotification, TurnErrorNotification, TurnExecProgressNotification, TurnHeartbeatNotification, TurnMediaPersistedNotification, TurnMediaProgressNotification, TurnMediaResultNotification, TurnPlanUpdateNotification, TurnReasoningDeltaNotification, TurnRecoveryNotification, TurnSidechainCompletedNotification, TurnSidechainStartedNotification, TurnSkillInstructionNotification, TurnStartNotification, TurnSubagentDeltaNotification, TurnSuggestionsNotification, TurnTaskUpdatedNotification, TurnTodosUpdatedNotification, TurnToolBlockedNotification, TurnToolCallNotification, TurnToolResultNotification, TurnToolUseSummaryNotification, TurnUsageUpdateNotification, WireTokenUsage, } from "./wire/index.js";