qlogicagent 2.19.13 → 2.20.1

package/dist/types/orchestration/agent-instance.d.ts

@@ -12,10 +12,11 @@
  *   5. product.checkpoint → manual checkpoint
  */
 import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-provider-directory.js";
-import type { ProductPhase, ProductCreateParams, ProductStatus, ProductSummary } from "../protocol/wire/acp-agent-management.js";
+import type { ProductPhase, ProductCreateParams, ProductStatus } from "../protocol/wire/acp-agent-management.js";
 import { type PlannerMemoryContext } from "./planner-memory-brief.js";
 import type { DagMutation } from "./product-planner.js";
 import type { ProductLeaderCoordinator } from "./product-run-coordinator.js";
+import { type HostRunStateAuthority } from "./run-state-host-authority.js";
 import type { DelegateBridge } from "./delegate-bridge.js";
 export type { ProductLeaderCoordinator } from "./product-run-coordinator.js";
 export interface ProductCallbacks {
@@ -41,7 +42,9 @@ export interface ProductCallbacks {
      *  warning notified the user while the actual auto-pause was log-only — the strongest budget
      *  intervention must be at least as loud as its warning. `reason` says WHICH limit tripped. */
     onBudgetExceeded?: (productId: string, usedTokens: number, maxTotalTokens: number | undefined, reason: string) => void;
-    onCompleted?: (productId: string, summary: string, phase: Extract<ProductPhase, "completed" | "failed">) => void;
+    onCompleted?: (productId: string, summary: string, phase: Extract<ProductPhase, "completed" | "failed">, projectId: string) => void | Promise<void>;
+    /** Host RunState writes are lifecycle barriers; failures stop the run and surface explicitly. */
+    onPersistenceError?: (productId: string, error: string, projectId: string) => void;
     /** DAG topology resolved and sent to client for visualization. */
     onDagTopology?: (productId: string, nodes: {
         id: string;
@@ -55,8 +58,7 @@ export interface ProductCallbacks {
     onBudgetUpdate?: (productId: string, inputTokens: number, outputTokens: number, elapsed: number, maxTotalTokens?: number) => void;
     /** Streaming text output from a running task. */
     onTaskOutputDelta?: (productId: string, taskId: string, text: string) => void;
-    /** Per-task tool activity heartbeat(delegate 路径由 sink.onToolCall 单发;旧路径经共享 PM 的
-     *  turn.tool_call 在 product-coordinator 转 product.agentActivity,PM 在 delegate 路径看不见 worker)。 */
+    /** Per-task tool activity heartbeat emitted from the supervised delegate event sink. */
     onTaskActivity?: (productId: string, taskId: string, toolName: string) => void;
     /** Team roster resolved at run start — fired once (engine-driven) for both initial start and resume,
      *  so the run view's 团队成员 panel populates live instead of only on a history reopen. */
@@ -64,8 +66,8 @@ export interface ProductCallbacks {
         agentId: string;
         role: string;
         name: string;
-    }[]) => void;
-    /** 激活层(S3c §1.2):gateway-routed delegate 桥(gate 关/未挂 = undefined → 旧本地 spawn 路径)。 */
+    }[], projectId: string) => void;
+    /** Required Gateway delegate access; orchestration fails loud when the Host rail is unavailable. */
     getDelegateBridge?: () => DelegateBridge | undefined;
 }
 /**
@@ -97,13 +99,18 @@ export declare class ProductOrchestrator {
     /**
      * Create a new Product Mode session.
      */
-    create(params: ProductCreateParams): Promise<string>;
+    create(params: ProductCreateParams, options?: {
+        authority?: HostRunStateAuthority;
+    }): Promise<string>;
     /** Resume a product from persisted state. */
-    resume(productId: string, cwd?: string, opts?: {
+    resume(productId: string, opts?: {
         additionalBudget?: {
             maxTotalTokens?: number;
             maxDuration?: number;
         };
+        authority?: HostRunStateAuthority;
+        projectId?: string;
+        cwd?: string;
     }): Promise<void>;
     /**
      * Pause a running product — the SINGLE pause path (I9).
@@ -126,11 +133,16 @@ export declare class ProductOrchestrator {
     private waitForInFlightSettle;
     /** Manual checkpoint. */
     checkpoint(productId: string): Promise<void>;
-    applyDagMutations(productId: string, mutations: readonly DagMutation[]): void;
-    /** Delete a product session, pausing first if active. */
-    delete(productId: string): Promise<void>;
-    /** Rollback a product to a checkpoint: delete running session then resume from disk. */
+    applyDagMutations(productId: string, mutations: readonly DagMutation[]): Promise<void>;
+    /** Delete a product session, including a persisted execution run after process restart. */
+    delete(productId: string, options?: {
+        authority?: HostRunStateAuthority;
+        projectId?: string;
+        cwd?: string;
+    }): Promise<void>;
+    /** Roll back a Product to a Host checkpoint and resume it through the same execution path. */
     rollback(productId: string, checkpoint?: string): Promise<void>;
+    private stopSessionForTeardown;
     /**
      * Replay from an arbitrary completed/failed task (CrewAI Crew.replay(taskId) parity).
      *
@@ -142,6 +154,7 @@ export declare class ProductOrchestrator {
      */
     replayTask(productId: string, taskId: string): Promise<void>;
     getStatus(productId: string): ProductStatus | null;
+    getProjectId(productId: string): string | undefined;
     /** Live DAG progress snapshot for a product (for the planner's execution-phase leader). */
     getProgressSnapshot(productId: string): {
         total: number;
@@ -149,16 +162,18 @@ export declare class ProductOrchestrator {
         running: number;
         failed: number;
     } | null;
-    getPersistedStatus(productId: string, cwd?: string): Promise<ProductStatus | null>;
-    /** List all products (in-memory + on-disk). */
-    list(cwd?: string): Promise<ProductSummary[]>;
     private scheduleNext;
+    private pauseForBudget;
+    private publishBudgetWarning;
     private isInstanceBusy;
     private dispatchTask;
+    private publishUnassignedTaskFailure;
     private runTask;
     private consultLeaderAfterFailure;
     private applyDagMutationsToSession;
     private finishProduct;
+    private failRunStatePersistence;
+    private publishNotification;
     private emitDagTopology;
     private cleanupInstanceWorktree;
     private buildPersistedState;

package/dist/types/orchestration/agent-roster.d.ts

@@ -4,8 +4,8 @@ import type { AgentRosterEntry } from "../protocol/wire/acp-agent-management.js"
  *  strengths hint + its backing model. Leader-only soft hints — NOT a capability contract.
  *
  *  `allowedAgents` is PRESENCE-based (an explicit `[]` is meaningful, NOT the same as omitted):
- *   - `undefined` / omitted → ALL ready agents (backward compatible — WS probes, other callers, old
- *     sessions). The allow-set is `null` and the catalog filter applies no constraint.
+ *   - `undefined` / omitted → ALL ready agents. The allow-set is `null` and the catalog filter applies
+ *     no constraint.
  *   - `[]` (explicit empty array) → ONLY the leader 小智 (qlogicagent): the allow-set is an empty Set, so
  *     the catalog filter drops every non-leader entry; the leader is force-included below → roster = just
  *     小智. This is the user deliberately deselecting every worker.

package/dist/types/orchestration/goal-loop-coordinator.d.ts

@@ -1,3 +1,4 @@
+import { type HostRunStateAuthority } from "./run-state-host-authority.js";
 import { type AcceptanceChecklist, type AcceptanceCriterion, type AcceptanceDelta, type GoalQueuedMessage, type PersistedGoalRunState, type PhaseSpec } from "./goal-run-types.js";
 export interface LeaderPort {
     deriveChecklist(goal: string): Promise<AcceptanceCriterion[]>;
@@ -26,18 +27,27 @@ export interface PhaseRunnerPort {
     }>;
 }
 export type GoalNotifier = (method: string, payload: Record<string, unknown>) => void;
+export interface GoalLoopCoordinatorDeps {
+    leader: LeaderPort;
+    runner: PhaseRunnerPort;
+    cwd: string;
+    projectId: string;
+    canonicalSessionId: string;
+    runStateAuthority?: HostRunStateAuthority;
+    notify?: GoalNotifier;
+    log?: {
+        warn(message: string): void;
+    };
+}
 export declare class GoalLoopCoordinator {
     private readonly deps;
     private seq;
     private opChain;
     private activeAbort;
-    constructor(deps: {
-        leader: LeaderPort;
-        runner: PhaseRunnerPort;
-        cwd: string;
-        notify?: GoalNotifier;
-    });
+    private readonly persistenceContext;
+    constructor(deps: GoalLoopCoordinatorDeps);
     private serialize;
+    private notify;
     private append;
     private persist;
     /** Launch a goal-run (instant, Codex-style). Returns the goalRunId. */
@@ -55,8 +65,8 @@ export declare class GoalLoopCoordinator {
      *  in-flight breadcrumb, then run the terminal checks. Called by BOTH the normal path and crash-recovery
      *  so neither duplicates this logic. Assess throwing propagates to the caller's failure handling. */
     private finishPhase;
-    /** B (crash-resume): re-attach to a Product that started before a crash. Rebuild it from its persisted
-     *  product-state.json and re-drive it to terminal (runner.resumePhase), then run the SAME phase tail
+    /** B (crash-resume): re-attach to a Product that started before a crash. Restore its Host RunState
+     *  checkpoint and re-drive it to terminal (runner.resumePhase), then run the SAME phase tail
      *  (finishPhase). Honest-fail ONLY if resume itself throws — a started phase is recovered, never lost,
      *  but progress is never fabricated. Bounded by an abort handle so pause() can still drain it. */
     private recoverCrashedPhase;

package/dist/types/orchestration/goal-mode-adapters.d.ts

@@ -2,6 +2,7 @@ import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-pro
 import type { DelegateBridge } from "./delegate-bridge.js";
 import { type PlannerMemoryContext } from "./planner-memory-brief.js";
 import type { ProductOrchestrator } from "./agent-instance.js";
+import type { HostRunStateAuthority } from "./run-state-host-authority.js";
 import type { LeaderPort, PhaseRunnerPort } from "./goal-loop-coordinator.js";
 import { type AcceptanceCriterion, type AcceptanceDelta, type PhaseSpec } from "./goal-run-types.js";
 /**
@@ -54,6 +55,8 @@ export interface LeaderAdapterDeps {
     leaderAgentId: string;
     /** Project workspaceDir — the leader process cwd. */
     cwd: string;
+    projectId: string;
+    canonicalSessionId: string;
     /** Live Product engine — assess() reads task outputs/changedFiles via getStatus. */
     orchestrator: ProductOrchestrator;
     /** Stable id used as the leader process memberId (one persistent leader per goal-run). */
@@ -65,13 +68,15 @@ export interface LeaderAdapterDeps {
         info(msg: string): void;
         warn(msg: string): void;
     };
-    /** 激活层(S3c §1.4):gateway-routed delegate 桥(gate 关/未挂 = undefined → 旧本地 spawn 路径)。 */
+    /** Required Gateway delegate access; Goal leader turns fail loud when unavailable. */
     getDelegateBridge?: () => DelegateBridge | undefined;
 }
 export declare function createLeaderAdapter(deps: LeaderAdapterDeps): LeaderPort;
 export interface PhaseRunnerAdapterDeps {
     /** The live Product engine (same one ProductRunCoordinator.confirmAndStart drives — I3). */
     orchestrator: ProductOrchestrator;
+    projectId: string;
+    runStateAuthority: HostRunStateAuthority;
     /** Optional per-phase budget passed through to ProductOrchestrator.create. */
     budget?: {
         maxTotalTokens?: number;

package/dist/types/orchestration/goal-run-persistence.d.ts

@@ -1,12 +1,14 @@
-import type { PathService } from "../runtime/ports/index.js";
 import type { GoalRunEvent, PersistedGoalRunState } from "./goal-run-types.js";
-export interface GoalPersistenceOptions {
-    pathService?: PathService;
+import type { HostRunStateAuthority } from "./run-state-host-authority.js";
+export interface GoalPersistenceContext {
+    projectId: string;
+    canonicalSessionId: string;
+    authority: HostRunStateAuthority;
 }
-/** Append one event as a fsync'd JSON line (the durable source of truth). */
-export declare function appendGoalRunEvent(goalRunId: string, event: GoalRunEvent, cwd?: string, o?: GoalPersistenceOptions): Promise<void>;
-export declare function readGoalRunEvents(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<GoalRunEvent[]>;
-export declare function saveGoalRunSnapshot(state: PersistedGoalRunState, cwd?: string, o?: GoalPersistenceOptions): Promise<void>;
-export declare function loadGoalRunSnapshot(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<PersistedGoalRunState | undefined>;
-/** Replay the event log into a snapshot (crash recovery). undefined if no goal_started. */
-export declare function rebuildSnapshotFromEvents(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<PersistedGoalRunState | undefined>;
+/** Append one event to the Gateway-owned durable RunState event log. */
+export declare function appendGoalRunEvent(goalRunId: string, event: GoalRunEvent, context: GoalPersistenceContext): Promise<void>;
+export declare function readGoalRunEvents(goalRunId: string, context: GoalPersistenceContext): Promise<GoalRunEvent[]>;
+export declare function saveGoalRunSnapshot(state: PersistedGoalRunState, context: GoalPersistenceContext): Promise<void>;
+export declare function loadGoalRunSnapshot(goalRunId: string, context: GoalPersistenceContext): Promise<PersistedGoalRunState | undefined>;
+/** Replay the Host event log into a snapshot. Returns undefined before goal_started. */
+export declare function rebuildSnapshotFromEvents(goalRunId: string, context: GoalPersistenceContext): Promise<PersistedGoalRunState | undefined>;

package/dist/types/orchestration/goal-run-types.d.ts

@@ -74,9 +74,11 @@ export interface GoalRunEvent {
     type: "goal_started" | "phase_planned" | "phase_started" | "task_settled" | "phase_assessed" | "progress_compacted" | "goal_edited" | "message_queued" | "paused" | "resumed" | "stopped" | "phase_boundary" | "ended";
     payload: Record<string, unknown>;
 }
-/** Derived snapshot (goal-run.json), rebuildable by replaying events. */
+/** Derived Goal checkpoint stored by Gateway RunState, rebuildable by replaying events. */
 export interface PersistedGoalRunState {
     goalRunId: string;
+    projectId: string;
+    canonicalSessionId: string;
     originalGoal: string;
     currentGoal: string;
     goalUpdatedAt?: string;
@@ -102,23 +104,3 @@ export interface PersistedGoalRunState {
     projectWorkspaceDir: string;
     lastEventSeq: number;
 }
-/** Pull-status shape returned by x/goal.status (GoalStatus, §5.1). */
-export interface GoalStatus {
-    goalRunId: string;
-    status: GoalRunStatus;
-    pauseState: GoalPauseState;
-    goalLabel: string;
-    currentGoal: string;
-    phaseIndex: number;
-    wallClockStartedAt: string;
-    progressSummary: string;
-    acceptance: {
-        passed: number;
-        total: number;
-        criteria: AcceptanceCriterion[];
-    };
-    queuedMessageCount: number;
-    noProgressCount: number;
-    endReason?: GoalEndReason;
-    failedReason?: string;
-}

package/dist/types/orchestration/index.d.ts

@@ -3,7 +3,6 @@ export { classifyError, isRetryableCategory, type ErrorCategory, } from "./error
 export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, type PostCompactRecoveryConfig, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "../runtime/context/context-compression-strategies.js";
 export { snipCompactIfNeeded, type SnipResult, } from "../runtime/context/context-compression-strategies.js";
 export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, type CollapseStore, type CollapseStage, } from "./context/context-collapse.js";
-export { buildSkillInstruction, recordPatternAndCheckThreshold, getPatternStats, buildToolSignature, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.js";
 export { applyToolChoicePolicy, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, } from "./tool-loop/tool-choice-policy.js";
 export { repairOpenAiChatConversation, type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiToolCall, } from "./tool-loop/conversation-repair.js";
 export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop/tool-loop-state.js";

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

@@ -3,14 +3,17 @@
  *
  * Rules:
  *  - Auto-checkpoint on task completion
- *  - 5 min fallback timer for active products
+ *  - 5 min periodic safety checkpoint for active products
  *  - 30 min timer for long-running products (>48h)
  *  - Manual checkpoint via product.checkpoint RPC
  */
 import type { PersistedProductState } from "./product-persistence.js";
+import type { HostRunStateAuthority } from "./run-state-host-authority.js";
 export interface CheckpointCallbacks {
     /** Called after each checkpoint save. */
     onCheckpoint?: (productId: string, timestamp: string) => void;
+    /** Called when an unattended periodic checkpoint cannot reach the Host authority. */
+    onError?: (productId: string, error: unknown) => void;
     /** Return current state snapshot for periodic auto-saves. */
     getState?: () => PersistedProductState | null;
     log?: {
@@ -20,16 +23,17 @@ export interface CheckpointCallbacks {
 }
 export declare class ProductCheckpointManager {
     private callbacks;
-    /** Fallback interval (5 min default, 30 min for >48h long-running). */
+    private readonly runStateAuthority;
+    /** Safety interval (5 min default, 30 min for >48h long-running). */
     private static readonly DEFAULT_INTERVAL;
     private static readonly LONG_RUNNING_INTERVAL;
     private static readonly LONG_RUNNING_THRESHOLD;
     private timer;
     private lastCheckpointAt;
-    private cwd?;
-    constructor(callbacks?: CheckpointCallbacks);
+    private checkpointTail;
+    constructor(callbacks: CheckpointCallbacks | undefined, runStateAuthority: HostRunStateAuthority);
     /** Start periodic checkpointing for a product. */
-    start(cwd?: string): void;
+    start(): void;
     /** Stop periodic checkpointing. */
     stop(): void;
     /** Get the appropriate checkpoint interval based on elapsed time. */
@@ -37,7 +41,7 @@ export declare class ProductCheckpointManager {
     /** Check if a checkpoint is due based on elapsed time since last checkpoint. */
     isDue(elapsedMs: number): boolean;
     /**
-     * Perform a checkpoint: save state to disk and notify.
+     * Perform a checkpoint through the captured Host RunState authority and notify.
      * Called on task completion or by periodic timer.
      */
     checkpoint(state: PersistedProductState): Promise<void>;

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

@@ -1,12 +1,13 @@
 /**
  * Product persistence facade over the Gateway-owned RunStateStore.
  */
-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";
+import { type HostRunStateAuthority } from "./run-state-host-authority.js";
 export interface PersistedProductState {
     productId: string;
+    projectId: string;
     name: string;
     phase: ProductPhase;
     cwd: string;
@@ -21,43 +22,69 @@ export interface PersistedProductState {
     };
     createdAt: string;
     lastCheckpointAt: string;
+    /** Last durably announced attempt number for each stable task id. */
+    taskAttempts?: Record<string, number>;
     /**
      * 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:
+     * context after a resume. JSON-safe:
      * PlanningSession is strings / arrays / plain objects (no functions, dates, or class instances).
      */
     leaderDialogue?: PlanningSession;
 }
+/** Host checkpoint used before a Product plan transitions into DAG execution. */
+export interface PersistedProductPlanningState {
+    stateKind: "planning";
+    productId: string;
+    projectId: string;
+    canonicalSessionId: string;
+    name: string;
+    phase: PlanningSession["phase"];
+    cwd: string;
+    instances: ProductInstanceDef[];
+    tasks: SerializedNode[];
+    budget: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    };
+    createdAt: string;
+    lastCheckpointAt: string;
+    planningSession: PlanningSession;
+}
 export interface ProductPersistenceOptions {
-    pathService?: PathService;
+    authority?: HostRunStateAuthority;
 }
-/** Save product state to disk. */
-export declare function saveProductState(state: PersistedProductState, cwd?: string, options?: ProductPersistenceOptions): Promise<void>;
-/** Load product state from disk. Returns undefined if not found. */
-export declare function loadProductState(productId: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
-/** List all product IDs with their persisted state. */
-export declare function listProducts(cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState[]>;
+/** Save Product execution state through the Gateway-owned RunState service. */
+export declare function saveProductState(state: PersistedProductState, options?: ProductPersistenceOptions): Promise<void>;
+export declare function saveProductPlanningState(session: PlanningSession, options?: ProductPersistenceOptions): Promise<PersistedProductPlanningState>;
+/** Load Product execution state through the Gateway-owned RunState service. */
+export declare function loadProductState(productId: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
+export declare function loadProductPlanningState(productId: string, owner: {
+    projectId: string;
+    canonicalSessionId: string;
+    cwd: string;
+}, options?: ProductPersistenceOptions): Promise<PersistedProductPlanningState | undefined>;
+/** Delete a Product run through Gateway authority. */
+export declare function deleteProductState(productId: string, options?: ProductPersistenceOptions): Promise<boolean>;
 /**
- * Save a full state snapshot into the checkpoints history directory.
+ * Save a full state snapshot into Gateway checkpoint history.
  * 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>;
+export declare function saveProductCheckpointSnapshot(state: PersistedProductState, 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>;
+export declare function loadProductCheckpointSnapshot(productId: string, timestamp: 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[]>;
+export declare function listProductCheckpointTimestamps(productId: 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).
+ * Restore a specific checkpoint as the latest Product state.
+ * Returns undefined if the Host no longer has that checkpoint.
  */
-export declare function restoreProductCheckpoint(productId: string, timestamp: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
+export declare function restoreProductCheckpoint(productId: string, timestamp: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;

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

@@ -26,7 +26,8 @@
 import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-provider-directory.js";
 import type { DelegateBridge } from "./delegate-bridge.js";
 import type { ProductPlanParams, ProductPlan, ProductConfirmParams } from "../protocol/wire/acp-agent-management.js";
-export type PlanningPhase = "planning" | "awaiting_confirmation" | "confirmed" | "executing" | "paused" | "completed" | "cancelled";
+import { type HostRunStateAuthority } from "./run-state-host-authority.js";
+export type PlanningPhase = "planning" | "awaiting_confirmation" | "confirmed" | "executing" | "paused" | "completed" | "failed" | "cancelled";
 export interface PlanningMessage {
     role: "leader" | "user";
     content: string;
@@ -34,6 +35,8 @@ export interface PlanningMessage {
 }
 export interface PlanningSession {
     productId: string;
+    projectId: string;
+    canonicalSessionId: string;
     goal: string;
     cwd: string;
     leaderAgentId: string;
@@ -41,6 +44,8 @@ export interface PlanningSession {
     activeDelegationId?: string;
     phase: PlanningPhase;
     plan?: ProductPlan;
+    /** Final user-approved execution payload, durably captured before DAG creation starts. */
+    confirmedExecution?: Pick<ProductConfirmParams, "instances" | "tasks" | "budget">;
     /** Multi-turn conversation history during planning. */
     dialogue: PlanningMessage[];
     budget?: {
@@ -60,6 +65,13 @@ export interface PlanningSession {
     lastCheckpoint?: string;
     /** A leader turn is currently running (planning is async/fire-and-forget) — block concurrent turns. */
     turnInFlight?: boolean;
+    failedReason?: string;
+}
+export interface ProductPlanningOwner {
+    projectId: string;
+    canonicalSessionId: string;
+    cwd: string;
+    authority?: HostRunStateAuthority;
 }
 export interface ProductPlanAskQuestion {
     question: string;
@@ -76,15 +88,15 @@ export interface PlannerCallbacks {
         warn(msg: string): void;
     };
     /** Leader produced a structured plan — client presents to user. */
-    onPlanReady?: (productId: string, plan: ProductPlan) => void;
+    onPlanReady?: (productId: string, plan: ProductPlan) => void | Promise<void>;
     /** Planning failed. */
-    onPlanFailed?: (productId: string, error: string) => void;
+    onPlanFailed?: (productId: string, error: string) => void | Promise<void>;
     /** Streaming text from leader during planning dialogue. */
     onPlanningDelta?: (productId: string, text: string) => void;
     /** Leader sent a message to user (multi-turn). */
-    onLeaderMessage?: (productId: string, message: string) => void;
+    onLeaderMessage?: (productId: string, message: string) => void | Promise<void>;
     /** Leader asked a structured clarifying question (turn-boundary); client renders an ask panel. */
-    onLeaderAsk?: (productId: string, askId: string, questions: ProductPlanAskQuestion[]) => void;
+    onLeaderAsk?: (productId: string, askId: string, questions: ProductPlanAskQuestion[]) => void | Promise<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). */
@@ -94,7 +106,7 @@ export interface PlannerCallbacks {
         running: number;
         failed: number;
     };
-    /** 激活层(S3c §1.3):gateway-routed delegate 桥(gate 关/未挂 = undefined → 旧本地 spawn 路径)。 */
+    /** Required Gateway delegate access; planning fails loud when the Host rail is unavailable. */
     getDelegateBridge?: () => DelegateBridge | undefined;
 }
 /** Describes a DAG mutation performed by the leader. */
@@ -107,7 +119,13 @@ export declare class ProductPlanner {
     private providerDirectory;
     private callbacks;
     private sessions;
+    private sessionAuthorities;
     constructor(providerDirectory: HostAgentProviderDirectory, callbacks?: PlannerCallbacks);
+    private resolveOwnerAuthority;
+    private assertSessionOwner;
+    private getOrRestoreSession;
+    private checkpointPlanningSession;
+    private publishNotification;
     /**
      * Start an interactive planning session (Phase 1).
      * Spawns the leader agent and begins multi-turn dialogue.
@@ -141,7 +159,7 @@ export declare class ProductPlanner {
      * Send a user message to the leader (works in planning and execution phases).
      * Returns the leader's response and optionally a finalized plan.
      */
-    message(productId: string, content: string): Promise<{
+    message(productId: string, content: string, owner?: ProductPlanningOwner): Promise<{
         response: string;
         plan?: ProductPlan;
         mutations?: DagMutation[];
@@ -153,14 +171,16 @@ export declare class ProductPlanner {
         productId: string;
         ok: true;
     }>;
-    /** Transition session to executing phase. Called after ProductOrchestrator.create(). */
+    /** Transition the in-memory leader session before the first execution checkpoint is written. */
     markExecuting(productId: string): void;
+    markAwaitingConfirmation(productId: string): Promise<void>;
+    getRunStateAuthority(productId: string): HostRunStateAuthority | undefined;
     /** Mark as completed. */
     markCompleted(productId: string): void;
     /** Get planning session by ID. */
     getSession(productId: string): PlanningSession | undefined;
     /** Cancel and kill leader process. */
-    cancel(productId: string): Promise<void>;
+    cancel(productId: string, owner?: ProductPlanningOwner): Promise<void>;
     /** List active sessions. */
     listSessions(): PlanningSession[];
     /**
@@ -206,7 +226,7 @@ export declare class ProductPlanner {
     /**
      * Restore session from checkpoint (crash recovery).
      */
-    restoreSession(data: PlanningSession): void;
+    restoreSession(data: PlanningSession, authority?: HostRunStateAuthority): void;
     private handlePlanningMessage;
     private handleExecutionMessage;
     private sendToLeader;

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

@@ -1,6 +1,7 @@
-import type { ProductConfirmParams, ProductPlan } from "../protocol/wire/acp-agent-management.js";
+import type { ProductConfirmParams, ProductMessageParams, ProductPlan } from "../protocol/wire/acp-agent-management.js";
 import type { ProductOrchestrator } from "./agent-instance.js";
 import type { DagMutation, PlanningSession, ProductPlanner } from "./product-planner.js";
+import type { HostRunStateAuthority } from "./run-state-host-authority.js";
 export interface ProductLeaderCoordinator {
     consultLeader(productId: string, context: {
         progress: {
@@ -30,7 +31,7 @@ export interface ProductLeaderCoordinator {
     /** 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;
+    restoreSession(data: PlanningSession, authority?: HostRunStateAuthority): void;
 }
 export declare class ProductRunCoordinator {
     private planner;
@@ -40,7 +41,7 @@ export declare class ProductRunCoordinator {
         productId: string;
         ok: true;
     }>;
-    message(productId: string, content: string): Promise<{
+    message(params: ProductMessageParams, authority?: HostRunStateAuthority): Promise<{
         response: string;
         plan?: ProductPlan;
         mutations?: DagMutation[];