qlogicagent 2.12.3 → 2.12.5

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -13,6 +13,7 @@
 import type { DreamTaskState, DreamTurn } from "../tasks/task-types.js";
 import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry, ForkedAgentRunnerFactory } from "../ports/agent-execution-contracts.js";
 import type { LLMTransport } from "../ports/index.js";
+import type { TaskStore } from "../infra/task-runtime.js";
 export interface DreamTriggerConfig {
     /** Minimum hours since last consolidation. Default: 24. */
     minHours: number;
@@ -99,17 +100,32 @@ export declare function shouldTriggerDream(ctx: DreamContext, config?: Partial<D
     sessionIds: string[];
 } | null>;
 /**
- * Attempt to acquire the consolidation lock.
+ * Attempt to acquire the consolidation liveness lock.
  *
- * @returns Prior mtime (for rollback) or null if blocked.
+ * A held lock is "live" only if its mtime is fresh (< MAX_DREAM_RUN_MS) AND the
+ * recorded PID is alive. A stale mtime reclaims unconditionally — this defends
+ * against a crashed holder whose PID was reused by an unrelated process (the old
+ * pure-PID check would falsely see it as alive and deadlock for up to an hour).
+ *
+ * @returns 0 on acquisition, or null if blocked by a live holder.
  */
 export declare function tryAcquireConsolidationLock(memoryRoot: string): Promise<number | null>;
 /**
- * Rollback the lock mtime after a failed dream run.
+ * Refresh the lock mtime so a long-but-legitimate dream is not reclaimed.
+ * Called periodically by the dream runner. No-op if we no longer own the lock.
+ */
+export declare function heartbeatConsolidationLock(memoryRoot: string): Promise<void>;
+/** Release the liveness lock explicitly (on failure, abort, or shutdown). */
+export declare function releaseConsolidationLock(memoryRoot: string): Promise<void>;
+/**
+ * Rollback after a FAILED dream run: release the lock. The gate marker is NOT
+ * touched (only success advances it), so a failed run never delays the next gate.
+ * `_priorMtime` is retained for call-site compatibility and ignored.
  */
-export declare function rollbackConsolidationLock(memoryRoot: string, priorMtime: number): Promise<void>;
+export declare function rollbackConsolidationLock(memoryRoot: string, _priorMtime: number): Promise<void>;
 /**
- * Update the lock file to record successful consolidation (mtime = now).
+ * Record a SUCCESSFUL consolidation: advance the gate marker (mtime = now) and
+ * release the liveness lock.
  */
 export declare function markConsolidationComplete(memoryRoot: string): Promise<void>;
 /** Create initial DreamTaskState. */
@@ -158,6 +174,8 @@ export interface DreamRunDeps {
     createAgentRunner: ForkedAgentRunnerFactory;
     /** Available tools (will be filtered by canUseDreamTool) */
     tools: ToolDefinition[];
+    /** Task store — when provided, the dream registers as a `dream` task (lifecycle visible to host + LLM). */
+    taskStore?: TaskStore;
     /** API key */
     apiKey: string;
     /** Model for dream */
@@ -213,6 +231,13 @@ export interface DreamRunDeps {
         getProfile?(userId: string, key: string): string | null;
         setProfile?(userId: string, key: string, value: string): void;
         getAllProfiles?(userId: string): Record<string, string>;
+        /** Drain consolidation backlog: resolve conflicts + promote corroborated pending claims. */
+        resolveConflicts?(userId: string, opts?: {
+            minEvidenceToPromote?: number;
+        }): Promise<{
+            conflictsResolved: number;
+            claimsPromoted: number;
+        }>;
     };
     /** User ID for memory operations. */
     memoryUserId?: string;

package/dist/types/runtime/execution/fork-context.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fork execution context — AsyncLocalStorage-based depth tracking.
+ *
+ * runForkedAgent() enters a child context at depth = parent + 1. Any tool
+ * executed inside that fork (including a nested `agent` tool call) reads the
+ * live depth via getCurrentForkDepth(), so the MAX_FORK_DEPTH guard operates
+ * on real values instead of a hardcoded 0.
+ *
+ * Top-level (no fork active) → depth 0.
+ */
+/** Current fork depth: 0 at top level, N inside an N-deep forked agent. */
+export declare function getCurrentForkDepth(): number;
+/** Run fn inside a fork context at the given depth. */
+export declare function runAtForkDepth<T>(depth: number, fn: () => T): T;

package/dist/types/runtime/infra/background-tasks.d.ts

@@ -0,0 +1,89 @@
+/**
+ * BackgroundTaskManager — the single registry for all background execution.
+ *
+ * Every background unit of work (forked agent, backgrounded shell command,
+ * dream consolidation) registers here so that:
+ *   1. The TaskStore holds its lifecycle state (task.updated notifications fire)
+ *   2. The LLM can query status/output via the task tool ("output" action)
+ *   3. Completion is queued as a <task_notification> for the next turn
+ *   4. Cancellation actually kills the underlying process / aborts the agent
+ *
+ * This is the ONLY producer surface for TaskStore background tasks.
+ * Do not register tasks into the store directly from feature code.
+ */
+import type { LocalAgentTaskState, LocalBashTaskState, TaskState } from "../tasks/task-types.js";
+import { type TaskStore } from "./task-runtime.js";
+/** Result contract for a background agent runner. */
+export interface AgentRunOutcome {
+    ok: boolean;
+    output?: string;
+    error?: string;
+}
+/** Structural handle for a backgrounded shell process (avoids skills-layer import). */
+export interface BashTaskHandle {
+    kill(): void;
+    result: Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    taskOutput: {
+        taskId: string;
+        path: string;
+    };
+}
+export interface StartAgentTaskOptions {
+    agentName: string;
+    label: string;
+    depth: number;
+    maxTurns: number;
+    parentTaskId?: string;
+    /** The actual work. Receives the task's own abort signal and task id. */
+    run(signal: AbortSignal, taskId: string): Promise<AgentRunOutcome>;
+}
+export interface RegisterBashTaskOptions {
+    command: string;
+    cwd: string;
+    label?: string;
+    pid?: number;
+    handle: BashTaskHandle;
+}
+export interface TaskOutputSnapshot {
+    task: TaskState;
+    /** Current output: final result for terminal tasks, live tail for running bash tasks. */
+    output: string;
+    running: boolean;
+}
+export declare class BackgroundTaskManager {
+    private readonly store;
+    private readonly controllers;
+    private readonly bashHandles;
+    private readonly settledListeners;
+    constructor(store: TaskStore);
+    /** Subscribe to natural task settlement (completed/failed). Returns unregister fn. */
+    onTaskSettled(listener: (task: TaskState) => void): () => void;
+    private fireSettled;
+    /**
+     * Start a background forked agent. Registers a local_agent task,
+     * floats the runner, and settles the task when the runner finishes.
+     */
+    startAgentTask(opts: StartAgentTaskOptions): LocalAgentTaskState;
+    /**
+     * Register an already-backgrounded shell command. The handle's result
+     * promise settles the task; live output is readable from outputPath.
+     */
+    registerBashTask(opts: RegisterBashTaskOptions): LocalBashTaskState;
+    private settle;
+    getTask(taskId: string): TaskState | undefined;
+    listTasks(): TaskState[];
+    /**
+     * Read a task's output. For running bash tasks this reads the live
+     * output file; for everything else it returns the stored final output.
+     */
+    readOutput(taskId: string): Promise<TaskOutputSnapshot | null>;
+    /**
+     * Cancel a running task: kills the shell process / aborts the agent,
+     * then marks the task cancelled. Returns false if not found or already terminal.
+     */
+    cancelTask(taskId: string): boolean;
+}

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

@@ -9,12 +9,8 @@
  * Architecture note: CC uses React-style setAppState(prev => next). We use
  * a simple Map-based store since we're in a subprocess (no React).
  */
-import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../tasks/task-types.js";
+import type { TaskState, TaskType, TaskLifecycle } from "../tasks/task-types.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
-/** Polling interval for running tasks (ms) */
-export declare const POLL_INTERVAL_MS = 1000;
-/** Display duration for killed tasks before eviction (ms) */
-export declare const STOPPED_DISPLAY_MS = 3000;
 /** Grace period for terminal tasks before eviction (ms) */
 export declare const PANEL_GRACE_MS = 30000;
 export declare function generateTaskId(type: TaskType): string;
@@ -68,41 +64,8 @@ export declare class TaskStore {
     evictStaleTasks(graceMs?: number): void;
 }
 export declare function isTerminalLifecycle(lifecycle: TaskLifecycle): boolean;
-/**
- * Transition a task to a terminal state.
- */
-export declare function completeTask(store: TaskStore, taskId: string): void;
-export declare function failTask(store: TaskStore, taskId: string, error?: string): void;
-export declare function cancelTask(store: TaskStore, taskId: string): void;
-/**
- * Create and register a local agent task.
- */
-export declare function createLocalAgentTask(store: TaskStore, opts: {
-    agentName: string;
-    systemPrompt: string;
-    allowedTools?: string[];
-    parentTaskId?: string;
-    tokenBudget?: number;
-    maxTurns?: number;
-    permissionRole?: PermissionRole;
-    isolation?: IsolationMode;
-    worktreeBranch?: string;
-}): LocalAgentTaskState;
-/**
- * Create and register a local bash task.
- */
-export declare function createLocalBashTask(store: TaskStore, opts: {
-    command: string;
-    cwd: string;
-    parentTaskId?: string;
-    label?: string;
-}): LocalBashTaskState;
 /**
  * Build a task notification message in CC's XML format.
  * This is injected into the conversation as context for the model.
  */
 export declare function buildTaskNotification(task: TaskState, summary: string): string;
-/**
- * Get the global task store singleton.
- */
-export declare function getTaskStore(): TaskStore;

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

@@ -11,15 +11,21 @@
  */
 import type { PermissionMode } from "../ports/permission-contracts.js";
 /**
- * The 7 task types from CC's sub-agent architecture.
+ * Sub-agent task types.
  *
- * - local_bash: Subprocess shell execution (bash/powershell)
- * - local_agent: Background forked Node process with its own tool loop
- * - remote_agent: Cloud environment (polling-based, e.g., CCR sandbox)
- * - in_process_teammate: Same process, AsyncLocalStorage-isolated agent
- * - local_workflow: DAG/pipeline execution (planned)
- * - monitor_mcp: MCP server monitoring agent (planned)
- * - dream: Background memory consolidation agent
+ * PRODUCED today (have a real registration site):
+ * - local_bash:  backgrounded shell command (BackgroundTaskManager.registerBashTask)
+ * - local_agent: backgrounded forked agent     (BackgroundTaskManager.startAgentTask)
+ * - 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)
+ * - in_process_teammate: AsyncLocalStorage-isolated same-process agent
+ *                        (team members currently spawn as local subprocesses, not this)
+ * - local_workflow:      DAG/pipeline execution
+ * - monitor_mcp:         MCP server monitoring agent
  */
 export type TaskType = "local_bash" | "local_agent" | "remote_agent" | "in_process_teammate" | "local_workflow" | "monitor_mcp" | "dream";
 /**
@@ -66,6 +72,10 @@ export interface TaskStateBase {
     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. */
@@ -74,6 +84,10 @@ export interface LocalBashTaskState extends TaskStateBase {
     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 {

package/dist/types/skills/memory/local-memory-provider.d.ts

@@ -76,6 +76,21 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     proposeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationResult>;
     listClaims(userId: string): MemoryClaimRecord[];
     listConflicts(userId: string): MemoryConflictRecord[];
+    /**
+     * Drain the consolidation backlog: auto-resolve open conflicts and promote
+     * corroborated pending claims. Called by dream after consolidation so the
+     * observation→proposal→claim pipeline doesn't accumulate unresolved state
+     * forever (the "proposals black hole").
+     *
+     * Conflict winner = higher source priority, then confidence, then recency.
+     * The loser claim is superseded and its backing memory archived.
+     */
+    resolveConflicts(userId: string, opts?: {
+        minEvidenceToPromote?: number;
+    }): Promise<{
+        conflictsResolved: number;
+        claimsPromoted: number;
+    }>;
     /**
      * Trigger memory decay - multi-strategy (temporal + staleness + noise).
      * Also enforces capacity limit and runs vacuum for space reclamation.

package/dist/types/skills/memory/local-store.d.ts

@@ -451,6 +451,17 @@ export declare class LocalMemoryStore {
         reason: string;
     }): string;
     listConflicts(userId: string): MemoryConflictRecord[];
+    getClaimById(id: string): MemoryClaimRecord | undefined;
+    setClaimStatus(id: string, status: MemoryClaimStatus): boolean;
+    /** Mark a conflict resolved (the resolver has already updated the claims). */
+    setConflictStatus(id: string, status: "open" | "resolved" | "dismissed"): boolean;
+    /** Open conflicts only (the ones needing resolution). */
+    listOpenConflicts(userId: string): MemoryConflictRecord[];
+    /**
+     * Promote pending_confirmation claims that have accumulated enough independent
+     * evidence to become active. Returns the number promoted.
+     */
+    promotePendingClaims(userId: string, minEvidence: number): number;
     insertAttachment(input: MemoryAttachmentInsert): void;
     getAttachmentById(id: string): MemoryAttachmentRow | null;
     listAttachmentsByMemoryId(memoryId: string): MemoryAttachmentRow[];

package/dist/types/skills/memory/memory-consolidation.d.ts

@@ -32,5 +32,12 @@ export declare class MemoryConsolidator {
     observe(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
     proposeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
     commitExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
+    /**
+     * Find an existing active memory that is a near-duplicate of `text`.
+     * Token containment (Latin/digit words + CJK bigrams) against recent
+     * memories; digit-bearing token mismatches veto the match because numbers
+     * and ids are precise facts, not phrasing variance.
+     */
+    private findNearDuplicateMemory;
 }
 export declare function sourcePriorityOf(source: string): number;

package/dist/types/skills/tools/agent-tool.d.ts

@@ -17,6 +17,8 @@ export interface AgentToolParams {
     maxTurns?: number;
     /** Run in background (returns task_id immediately). */
     background?: boolean;
+    /** Inherit a trimmed prefix of the parent conversation (default false). */
+    inheritContext?: boolean;
 }
 export declare const AGENT_TOOL_SCHEMA: {
     readonly type: "object";
@@ -40,13 +42,18 @@ export declare const AGENT_TOOL_SCHEMA: {
         };
         readonly background: {
             readonly type: "boolean";
-            readonly description: "If true, runs in background and returns a task_id. Poll with task tool. Default: false.";
+            readonly description: string;
+        };
+        readonly inheritContext: {
+            readonly type: "boolean";
+            readonly description: string;
         };
     };
     readonly required: readonly ["agent", "prompt"];
     readonly additionalProperties: false;
 };
 export interface AgentResult {
+    /** Foreground: synthetic fork id. Background: real TaskStore task id (poll via task tool). */
     agentId: string;
     status: "completed" | "running" | "failed";
     output?: string;
@@ -55,22 +62,25 @@ export interface AgentResult {
     tokensUsed?: number;
 }
 /**
- * Host-provided fork execution backend (CC-aligned).
+ * Host-provided fork execution backend.
  *
- * Key properties of the fork mechanism:
- * 1. Child shares parent's message prefix (prompt cache hit)
- * 2. Child uses byte-identical prefix via placeholder results
- * 3. Child has independent tool context (isolation)
- * 4. Results flow back via in-memory streaming (not DB)
- * 5. Fork depth tracked in-memory (max 4 layers)
+ * Actual behavior (not aspirational):
+ * - The child starts FRESH by default: it receives only the `prompt` as a single
+ *   user message. With inheritContext=true (foreground only), the host prepends a
+ *   trimmed, budget-capped slice of the parent conversation (no system prompt,
+ *   media/tool plumbing stripped) — best-effort cache reuse, NOT byte-identical.
+ * - Child inherits the parent's tool pool, filtered by the agent definition.
+ * - Fork depth is tracked via AsyncLocalStorage; spawns past MAX_FORK_DEPTH are rejected.
+ * - Output is returned via in-memory streaming (not DB).
  */
 export interface AgentToolDeps {
     /**
      * Fork and run a sub-agent.
      * The implementation must:
-     * - Share parent's rendered system prompt (byte-identical for cache)
+     * - Pass `prompt` as the child's task; if inheritContext, prepend the parent
+     *   conversation slice (foreground only — background always starts fresh)
      * - Inherit parent's tool pool (filtered by agent definition)
-     * - Track fork depth (reject if > MAX_FORK_DEPTH)
+     * - Track fork depth (reject if >= MAX_FORK_DEPTH)
      * - Return output via in-memory streaming backflow
      */
     forkAgent(params: {
@@ -79,6 +89,7 @@ export interface AgentToolDeps {
         description?: string;
         maxTurns?: number;
         background?: boolean;
+        inheritContext?: boolean;
         abortSignal?: AbortSignal;
     }): Promise<AgentResult>;
     /** Abort signal from the parent turn. */

package/dist/types/skills/tools/exec-tool.d.ts

@@ -1,4 +1,5 @@
 import type { PortableTool } from "../portable-tool.js";
+import type { BashTaskHandle } from "../../runtime/infra/background-tasks.js";
 import type { CommandClassification } from "./shell/command-classification.js";
 import type { SandboxConfig } from "./shell/sandbox/sandbox-types.js";
 export declare const EXEC_TOOL_NAME: "exec";
@@ -89,6 +90,18 @@ export interface ExecToolHost {
      * The host can forward these to the UI for real-time output display.
      */
     onProgress?(progress: ExecProgress): void;
+    /**
+     * Register a backgrounded command in the host's unified task registry
+     * (lifecycle tracking + output queries + cancellation).
+     * Returns false when the host has no registry — background mode is then refused.
+     */
+    registerBackgroundTask?(info: {
+        command: string;
+        cwd: string;
+        description?: string;
+        pid?: number;
+        handle: BashTaskHandle;
+    }): boolean;
 }
 /**
  * Auto-background trigger threshold (assistant mode).

package/dist/types/skills/tools/monitor-tool.d.ts

@@ -36,12 +36,12 @@ export declare const MONITOR_TOOL_SCHEMA: {
         };
         readonly source: {
             readonly type: "string";
-            readonly enum: readonly ["process", "file", "task", "custom"];
-            readonly description: "Type of event source to watch.";
+            readonly enum: readonly ["file"];
+            readonly description: "Type of event source to watch. Currently only \"file\" is supported.";
         };
         readonly target: {
             readonly type: "string";
-            readonly description: string;
+            readonly description: "Selector for the monitored target. For file: a path or glob pattern.";
         };
         readonly conditions: {
             readonly type: "array";

package/dist/types/skills/tools/send-message-tool.d.ts

@@ -30,6 +30,12 @@ export interface SendMessageResult {
     success: boolean;
     recipients?: string[];
     error?: string;
+    /** Replies collected from the recipient(s) — the message loop is synchronous. */
+    replies?: Array<{
+        memberId: string;
+        name: string;
+        reply: string;
+    }>;
 }
 /**
  * Host-provided message routing backend.

package/dist/types/skills/tools/shell/index.d.ts

@@ -9,7 +9,7 @@ export { SAFE_ENV_VARS, BARE_SHELL_PREFIXES, stripSafeWrappers, stripAllLeadingE
 export { getDestructiveCommandWarning, getPowerShellDestructiveCommandWarning, } from "./destructive-command-warning.js";
 export type { CommandSemanticResult } from "./command-semantics.js";
 export { interpretCommandResult } from "./command-semantics.js";
-export { TaskOutput, generateTaskId, getTaskOutputDir, setTaskOutputDir, getTaskOutputPath, MAX_TASK_OUTPUT_BYTES, } from "./task-output.js";
+export { TaskOutput, getTaskOutputDir, setTaskOutputDir, getTaskOutputPath, MAX_TASK_OUTPUT_BYTES, } from "./task-output.js";
 export type { ProgressCallback } from "./task-output.js";
 export type { ExecResult, ShellCommand } from "./shell-command.js";
 export { wrapSpawn, createAbortedCommand, createFailedCommand, } from "./shell-command.js";

package/dist/types/skills/tools/shell/task-output.d.ts

@@ -8,7 +8,6 @@ export declare function getTaskOutputDir(): string;
 /** Set the task output directory (for embedding hosts to override). */
 export declare function setTaskOutputDir(dir: string): void;
 export declare function getTaskOutputPath(taskId: string): string;
-export declare function generateTaskId(prefix?: string): string;
 /**
  * Single source of truth for a shell command's output.
  * Ported from cc's TaskOutput.

package/dist/types/skills/tools/task-tool.d.ts

@@ -1,7 +1,34 @@
 import type { PortableTool } from "../portable-tool.js";
 export declare const TASK_TOOL_NAME: "task";
-export declare const TASK_ACTIONS: readonly ["create", "update", "delete", "list", "get"];
+export declare const TASK_ACTIONS: readonly ["create", "update", "delete", "list", "get", "output", "cancel"];
 export type TaskAction = (typeof TASK_ACTIONS)[number];
+/**
+ * Structural view of the host's background task registry
+ * (implemented by BackgroundTaskManager; kept structural so this file stays zero-dep).
+ */
+export interface TaskRuntimeAccess {
+    getTask(taskId: string): RuntimeTaskView | undefined;
+    listTasks(): RuntimeTaskView[];
+    readOutput(taskId: string): Promise<{
+        task: RuntimeTaskView;
+        output: string;
+        running: boolean;
+    } | null>;
+    cancelTask(taskId: string): boolean;
+}
+export interface RuntimeTaskView {
+    taskId: string;
+    type: string;
+    label: string;
+    lifecycle: string;
+    startedAt: number;
+    endedAt?: number;
+    error?: string;
+}
+export interface TaskToolRuntimeDeps {
+    /** Live accessor — the registry is bound by the host after bootstrap. */
+    getRuntime(): TaskRuntimeAccess | null;
+}
 export type TaskStatus = "not-started" | "in-progress" | "completed";
 export declare const TASK_STATUS_VALUES: readonly TaskStatus[];
 export interface TaskItem {
@@ -23,6 +50,7 @@ export interface TaskListSummary {
 export interface TaskToolParams {
     action: TaskAction;
     id?: number;
+    taskId?: string;
     title?: string;
     description?: string;
     status?: TaskStatus;
@@ -35,12 +63,16 @@ export declare const TASK_TOOL_SCHEMA: {
     readonly properties: {
         readonly action: {
             readonly type: "string";
-            readonly enum: readonly ["create", "update", "delete", "list", "get"];
+            readonly enum: readonly ["create", "update", "delete", "list", "get", "output", "cancel"];
             readonly description: string;
         };
         readonly id: {
             readonly type: "number";
-            readonly description: "[update|delete|get] Task id to operate on.";
+            readonly description: "[update|delete|get] Checklist task id to operate on.";
+        };
+        readonly taskId: {
+            readonly type: "string";
+            readonly description: "[output|cancel] Background task id (returned by agent background=true / exec background=true).";
         };
         readonly title: {
             readonly type: "string";
@@ -57,7 +89,7 @@ export declare const TASK_TOOL_SCHEMA: {
         };
         readonly owner: {
             readonly type: "string";
-            readonly description: "[create|update] Owner agent/subagent identifier.";
+            readonly description: string;
         };
         readonly addBlocks: {
             readonly type: "array";
@@ -90,4 +122,4 @@ export declare function summarizeTaskList(items: readonly TaskItem[]): TaskListS
 /**
  * Create a stateful task tool instance (V2 — CC TaskCreate/Update/List/Get aligned).
  */
-export declare function createTaskTool(options?: TaskToolOptions, hooks?: TaskToolHooks): PortableTool<TaskToolParams>;
+export declare function createTaskTool(options?: TaskToolOptions, hooks?: TaskToolHooks, runtimeDeps?: TaskToolRuntimeDeps): PortableTool<TaskToolParams>;

package/dist/types/skills/tools/team-tool.d.ts

@@ -79,6 +79,11 @@ export interface TeamResult {
     team?: Team;
     teams?: Team[];
     error?: string;
+    /** Members that failed to spawn (team still created with the survivors). */
+    partialFailures?: Array<{
+        name: string;
+        error: string;
+    }>;
 }
 /**
  * Host-provided team management backend.

package/dist/types/transport/acp-server.d.ts

@@ -92,7 +92,6 @@ export interface AcpRequestHandler {
     handleAcpProductRollback(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductStatus(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductSubscribe(params: Record<string, unknown>): Promise<unknown>;
-    handleAcpTeamDelegate(params: Record<string, unknown>): Promise<unknown>;
 }
 export interface AcpServerConfig {
     verbose?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.12.3",
+  "version": "2.12.5",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",