qlogicagent 2.24.1 → 2.24.2

package/dist/types/host-contract/memory-category.d.ts

@@ -1,8 +0,0 @@
-/** Host-owned taxonomy shared by every long-term-memory producer and consumer. */
-export declare const LONG_TERM_MEMORY_CATEGORIES: readonly ["fact", "preference", "insight", "lesson", "decision", "plan", "event", "pattern", "context", "procedure", "general"];
-export type LongTermMemoryCategory = (typeof LONG_TERM_MEMORY_CATEGORIES)[number];
-/** Logical relation between an atomic claim slot and its structured value. */
-export declare const MEMORY_CLAIM_RELATIONS: readonly ["equals", "includes", "excludes"];
-export type MemoryClaimRelation = (typeof MEMORY_CLAIM_RELATIONS)[number];
-export declare function normalizeLongTermMemoryCategory(value: unknown, fallback?: LongTermMemoryCategory): LongTermMemoryCategory;
-export declare function normalizeMemoryClaimRelation(value: unknown, fallback?: MemoryClaimRelation): MemoryClaimRelation;

package/dist/types/host-contract/skill-category.d.ts

@@ -1,5 +0,0 @@
-/** Host-owned taxonomy shared by skill promotion, persistence, and UI. */
-export declare const HUB_SKILL_CATEGORIES: readonly ["efficiency", "dev", "cloud", "data", "industrial", "marketing", "ecommerce", "procurement", "hr", "accounting", "finance", "legal", "lifestyle"];
-export type HubSkillCategory = (typeof HUB_SKILL_CATEGORIES)[number];
-export declare const HUB_SKILL_CATEGORY_LABELS: Readonly<Record<HubSkillCategory, string>>;
-export declare function isHubSkillCategory(value: unknown): value is HubSkillCategory;

package/dist/types/host-session-collection-contract.d.ts

@@ -1,65 +0,0 @@
-/**
- * Browser-safe Host session collection protocol.
- *
- * This is the common protocol layer shared by Gateway and renderer clients. It intentionally has
- * no Node/runtime imports; Host services and native Providers remain behind the Gateway facade.
- */
-import type { AgentId, CanonicalSessionId, NativeSessionRef, ProjectId } from "./host-contract/index.js";
-export type HostSessionTitleSource = "prompt" | "generated" | "user" | "native" | "repaired";
-export type HostSessionLifecycle = "active" | "archived" | "source-missing" | "resume-unavailable";
-export type HostSessionCommand = "host.setPinned" | "host.rename" | "host.setArchived" | "host.deleteRecord";
-export type HostSessionCollectionScope = {
-    kind: "project";
-    projectId: ProjectId;
-} | {
-    kind: "workspace-tree";
-};
-export interface HostSessionSummary {
-    resourceId: string;
-    canonicalSessionId?: CanonicalSessionId;
-    source: "host" | "native-unadopted";
-    projectId: ProjectId;
-    agentId: AgentId;
-    title?: string;
-    titleSource?: HostSessionTitleSource;
-    lastActiveAt: string;
-    pinnedAt?: string;
-    lifecycle: HostSessionLifecycle;
-    /** Host-authorized mutation surface. Renderer commands are a projection of this list. */
-    availableCommands: HostSessionCommand[];
-    nativeRef?: NativeSessionRef;
-}
-export interface HostSessionProviderDiagnostic {
-    agentId: AgentId;
-    projectId: ProjectId;
-    code: string;
-    message: string;
-    lastGoodRevision?: number;
-}
-export interface HostSessionCollectionSnapshot {
-    revision: number;
-    scopeGeneration: number;
-    items: HostSessionSummary[];
-    diagnostics: HostSessionProviderDiagnostic[];
-}
-export interface HostSessionCollectionDelta {
-    revision: number;
-    scopeGeneration: number;
-    addedOrUpdated?: HostSessionSummary[];
-    removed?: string[];
-    diagnostics?: HostSessionProviderDiagnostic[];
-}
-/** Provider-owned transcript wire shape. The renderer consumes this exact shape through Host RPC. */
-export interface NativeTranscriptMessage {
-    id?: string;
-    role: "user" | "assistant" | "tool";
-    content: unknown;
-    createdAt?: string;
-}
-export interface NativeTranscript {
-    messages: NativeTranscriptMessage[];
-    diagnostics?: unknown[];
-}
-export declare function isNativeTranscript(value: unknown): value is NativeTranscript;
-export declare function isHostSessionCollectionSnapshot(value: unknown): value is HostSessionCollectionSnapshot;
-export declare function isHostSessionCollectionDelta(value: unknown): value is HostSessionCollectionDelta;

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

@@ -1,215 +0,0 @@
-/**
- * Agent Instance — Product Mode orchestrator.
- *
- * Manages the lifecycle of a Product: creating instances (agents),
- * scheduling tasks via DAG, enforcing budget, checkpointing state.
- *
- * Flow:
- *   1. product.create → validate DAG, create instances, start scheduling
- *   2. DAG readyTasks → spawn agent → sendTask → on complete → markCompleted → checkpoint
- *   3. product.pause → pause all, checkpoint
- *   4. product.resume → load state, resume scheduling
- *   5. product.checkpoint → manual checkpoint
- */
-import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-provider-directory.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 ProductFailureAssigneeSelection {
-    productId: string;
-    taskId: string;
-    taskPrompt: string;
-    error: string;
-    current: {
-        name: string;
-        agentId: string;
-    };
-    candidates: Array<{
-        name: string;
-        agentId: string;
-    }>;
-}
-export type ProductFailureAssigneeSelector = (input: ProductFailureAssigneeSelection) => Promise<string | undefined>;
-export interface ProductCallbacks {
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-    onTaskStarted?: (productId: string, taskId: string, assignee: string, attempt: number) => void;
-    onTaskCompleted?: (productId: string, taskId: string, result: string, meta: {
-        attempt: number;
-        inputTokens: number;
-        outputTokens: number;
-        changedFiles: string[];
-        acceptanceUnverified?: boolean;
-    }) => void;
-    onTaskFailed?: (productId: string, taskId: string, error: string, meta: {
-        attempt: number;
-        terminalState: "failed" | "cancelled";
-    }) => void;
-    /** Explicit receipt for the one automatic abnormal-worker handoff. */
-    onTaskHandoff?: (productId: string, taskId: string, from: string, to: string, reason: string, attempt: number) => void;
-    onCheckpointed?: (productId: string, timestamp: string) => void;
-    onBudgetWarning?: (productId: string, usedTokens: number, maxTotalTokens: number, percentage: number) => void;
-    /** Budget hard limit hit → the run auto-paused. The 100% counterpart of onBudgetWarning (80%): the
-     *  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">, 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;
-        label: string;
-        deps: string[];
-    }[], edges: {
-        from: string;
-        to: string;
-    }[]) => void;
-    /** Real-time budget consumption update. */
-    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 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. */
-    onMembers?: (productId: string, members: {
-        agentId: string;
-        role: string;
-        name: string;
-    }[], projectId: string) => void;
-    /** Required Gateway delegate access; orchestration fails loud when the Host rail is unavailable. */
-    getDelegateBridge?: () => DelegateBridge | undefined;
-}
-/**
- * Prepend completed upstream task outputs to a downstream task prompt so the
- * worker agent can see what its predecessors produced (research→writing, etc.).
- * If there are no upstream outputs the original prompt is returned unchanged.
- *
- * NOTE: Only used for the agent-facing sends (spawn/sendTask/recovery).
- * The original prompt is kept separate for evidence heuristics
- * (requiresExplicitCompletionEvidence, assertProductTaskCompletionEvidence,
- * assertProductTaskMaterializedEvidence) which inspect the task instruction
- * for specific markers and keywords — the context prefix must not pollute them.
- */
-export declare function buildTaskContextPrompt(upstream: {
-    taskId: string;
-    output: string;
-}[], prompt: string): string;
-export declare class ProductOrchestrator {
-    private providerDirectory;
-    private callbacks;
-    private leaderCoordinator?;
-    private sessions;
-    constructor(providerDirectory: HostAgentProviderDirectory, callbacks?: ProductCallbacks, leaderCoordinator?: ProductLeaderCoordinator | undefined);
-    setLeaderCoordinator(leaderCoordinator: ProductLeaderCoordinator): void;
-    /** (a) Owner global cheat-sheet source for member dispatches (cli-injected;
-     * orchestration never imports skills directly). */
-    private memoryContext?;
-    setMemoryContext(memoryContext: PlannerMemoryContext): void;
-    /**
-     * Create a new Product Mode session.
-     */
-    create(params: ProductCreateParams, options?: {
-        authority?: HostRunStateAuthority;
-        failureAssigneeSelector?: ProductFailureAssigneeSelector;
-    }): Promise<string>;
-    /** Resume a product from persisted state. */
-    resume(productId: string, opts?: {
-        additionalBudget?: {
-            maxTotalTokens?: number;
-            maxDuration?: number;
-        };
-        authority?: HostRunStateAuthority;
-        projectId?: string;
-        cwd?: string;
-        failureAssigneeSelector?: ProductFailureAssigneeSelector;
-    }): Promise<void>;
-    /**
-     * Pause a running product — the SINGLE pause path (I9).
-     *
-     * `drainTimeoutMs` selects the behavior along ONE mechanism, not separate code paths:
-     *   - `0` (default): instant pause — no drain wait, the loop below force-kills any running
-     *     instances immediately. This is Product's historical hard-kill UX, expressed as a parameter.
-     *   - `> 0`: graceful drain — stop dispatching NEW tasks, then wait up to `drainTimeoutMs` for
-     *     in-flight tasks to settle (inFlightTasks → 0). After a clean drain there is nothing left
-     *     running so the loop kills nothing; on timeout the SAME loop force-kills the stragglers.
-     *
-     * `session.phase` flips to "paused" only AFTER draining, so a run mid-drain is observably still
-     * active (not yet paused).
-     */
-    pause(productId: string, options?: {
-        drainTimeoutMs?: number;
-    }): Promise<void>;
-    /** Poll `session.inFlightTasks` until it settles to 0 or the deadline elapses. The sole drain
-     *  primitive for {@link pause} — there is no other place that waits for tasks to settle. */
-    private waitForInFlightSettle;
-    /** Manual checkpoint. */
-    checkpoint(productId: string): Promise<void>;
-    applyDagMutations(productId: string, mutations: readonly DagMutation[]): Promise<import("./product-dag-mutation-applier.js").ProductDagMutationApplyResult>;
-    /** 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).
-     *
-     * Resets the task + all its transitive descendants to pending (clearing their outputs) while
-     * leaving ancestors completed — so the re-run automatically reuses upstream outputs via the
-     * existing task-context injection (getUpstreamOutputs at dispatch). Unlike rollback (which
-     * restores a whole-product checkpoint) or retryNode (which only accepts FAILED nodes), replay
-     * targets a successful-but-wrong task and re-runs forward from it in place.
-     */
-    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;
-        completed: number;
-        running: number;
-        failed: number;
-    } | null;
-    private scheduleNext;
-    private pauseForBudget;
-    private publishBudgetWarning;
-    private isInstanceBusy;
-    private dispatchTask;
-    private publishUnassignedTaskFailure;
-    private runTask;
-    private consultLeaderAfterFailure;
-    private tryAutomaticAgentHandoff;
-    private applyDagMutationsToSession;
-    private finishProduct;
-    /**
-     * Durable persistence failed → the run is over. Declaring that is not enough: the in-flight work has
-     * to actually stop.
-     *
-     * This used to only set phase and stop the checkpoint timer, so with 3 parallel tasks the run went
-     * "failed" for the client while the other 2 kept executing for up to their full timeout — still
-     * writing worktrees and still issuing EXPLICIT checkpoints (`stop()` only cancels the periodic
-     * timer, it does not block direct writes). The persisted state then drifted into phase=failed with
-     * tasks=completed, `finishProduct` never ran, and the session stayed in the map forever.
-     *
-     * `session.cancelled` is the existing single flag that closes all of that: it makes in-flight tasks
-     * treat their outcome as non-failure, aborts the retry loops, and short-circuits the post-task
-     * checkpoint + scheduleNext. Kept synchronous (14 call sites, several inside sync paths) — the
-     * per-task `finally` already tears down each task worktree, so no async cleanup is needed here.
-     */
-    private failRunStatePersistence;
-    private publishNotification;
-    private emitDagTopology;
-    private cleanupInstanceWorktree;
-    private buildPersistedState;
-}

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

@@ -1,32 +0,0 @@
-import type { HostAgentProviderListResult } from "../host-contract/index.js";
-import type { AgentRosterEntry } from "../protocol/wire/acp-agent-management.js";
-interface AgentRosterOptions {
-    injectLeader?: boolean;
-    leaderAgentId: string;
-}
-/** Build the team roster the leader sees during planning: every ready agent with a coarse
- *  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. The allow-set is `null` and the catalog filter applies
- *     no constraint.
- *   - `[]` (explicit empty array) → ONLY the selected session leader: the allow-set is empty, so the
- *     catalog filter drops every non-leader entry. This is the user deliberately deselecting workers.
- *   - `[ids]` → those ready ids PLUS the selected leader. A picked-but-unready id is dropped.
- *
- *  The caller supplies the authoritative leader id from the session binding. There is no implicit
- *  leader: Product callers pass their Product leader; Goal callers pass the session owner. */
-export declare function buildAgentRoster(snapshot: Readonly<HostAgentProviderListResult>, allowedAgents: string[] | undefined, options: AgentRosterOptions): AgentRosterEntry[];
-/**
- * User-PICKED worker ids that did NOT make it into the roster (unready: not installed / not logged in
- * / not in the catalog). Excludes the leader (always force-included). Empty when nothing was dropped
- * or when the pool was omitted. Callers surface this so a picked worker doesn't vanish silently and
- * collapse the team to just its leader (honesty over silence).
- */
-export declare function computeUnavailablePicks(allowedAgents: string[] | undefined, rosterIds: readonly string[], leaderAgentId: string): string[];
-/** buildAgentRoster + the diagnostics of which picked workers were dropped as unavailable. */
-export declare function buildAgentRosterWithDiagnostics(snapshot: Readonly<HostAgentProviderListResult>, allowedAgents: string[] | undefined, options: AgentRosterOptions): {
-    roster: AgentRosterEntry[];
-    unavailablePicks: string[];
-};
-export {};

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

@@ -1,219 +0,0 @@
-/**
- * DAG Scheduler v2 — unified scheduling for Product + Automation modes.
- *
- * Single-track model: one algorithm, no compat shims, no legacy paths.
- * Product mode = flat DAG (kind:"agent", no conditions, no loops) — strict subset.
- *
- * Spec: docs/dag-scheduler-v2-spec.md
- */
-import type { ProductTaskStatus } from "../protocol/wire/acp-agent-management.js";
-/**
- * Loop safety hard ceiling (plan D15): a loop controller's `maxIterations` is required and may
- * never exceed this. Unattended/triggered runs must not be able to declare an effectively
- * unbounded loop, so a value above the cap is rejected fail-loud at construction — not clamped.
- */
-export declare const LOOP_MAX_ITERATIONS_HARD_CAP = 1000;
-/** Unified node status; "skipped" is a terminal success (intentionally not run). */
-export type NodeStatus = ProductTaskStatus;
-/**
- * Fully-materialized runtime node (constructed from NodeDef, never partial).
- * Internal to the scheduler — do not mutate directly outside DagScheduler.
- */
-export interface Node {
-    id: string;
-    kind: string;
-    params: Record<string, unknown>;
-    status: NodeStatus;
-    outPorts: string[];
-    joinPolicy: "all" | "any";
-    firedPorts?: string[];
-    output?: unknown;
-    error?: string;
-    startedAt?: number;
-    completedAt?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    changedFiles?: string[];
-    acceptanceUnverified?: boolean;
-    runIndex: number;
-    maxIterations?: number;
-    iteration?: number;
-}
-/** Declarative input for the constructor. Edges derived from dependsOn. */
-export interface NodeDef {
-    id: string;
-    kind?: string;
-    params?: Record<string, unknown>;
-    dependsOn?: string[];
-    outPorts?: string[];
-    joinPolicy?: "all" | "any";
-    maxIterations?: number;
-}
-export interface Edge {
-    from: string;
-    to: string;
-    fromPort?: string;
-    loopBack?: boolean;
-}
-export declare class DagScheduler {
-    private nodes;
-    private edges;
-    constructor(defs: NodeDef[]);
-    getNode(id: string): Node | undefined;
-    getAllNodes(): Node[];
-    /**
-     * Ready = pending + all forward incoming edges satisfied (or no incoming edges).
-     * Spec §3.1.
-     */
-    getReadyNodes(): Node[];
-    isFinished(): boolean;
-    /** All nodes completed or skipped (skipped = intentionally not run, counts as success). */
-    isAllCompleted(): boolean;
-    getBlockedNodes(): Node[];
-    getProgress(): {
-        total: number;
-        completed: number;
-        running: number;
-        failed: number;
-        pending: number;
-        paused: number;
-        skipped: number;
-    };
-    markRunning(id: string): void;
-    /**
-     * Mark completed. firedPorts omitted → all outPorts fire (agent/tool nodes).
-     * Triggers skip propagation (§3.2).
-     */
-    markCompleted(id: string, out: {
-        output?: unknown;
-        firedPorts?: string[];
-        inputTokens?: number;
-        outputTokens?: number;
-        changedFiles?: string[];
-        acceptanceUnverified?: boolean;
-    }): void;
-    /**
-     * Mark failed. Terminal states are immutable: a node that already completed, was skipped, or
-     * already failed is left untouched.
-     *
-     * Without this guard markFailed was the one lifecycle transition with no precondition (markRunning /
-     * markCompleted / markSkipped all have one), so teardown and replay — which both call it on whatever
-     * task an instance last held — could rewrite a real success as a failure, erase its output, and then
-     * propagateSkips() would block the downstream that success had unlocked. Keeping the FIRST error also
-     * stops a late generic rejection ("gateway torn down") from burying the actual diagnosis.
-     */
-    markFailed(id: string, error: string): void;
-    markPaused(id: string): void;
-    resumePaused(id: string): void;
-    markSkipped(id: string): void;
-    pauseAll(): void;
-    resumeAll(): void;
-    /**
-     * Loop controller decision (§3.3).
-     * If again && iterations remain → reset loop body, fire "loop" port.
-     * Otherwise → fire "done" port (exit).
-     */
-    decideLoop(loopId: string, again: boolean): void;
-    addNode(def: NodeDef): void;
-    /** Add multiple nodes atomically. All-or-nothing. */
-    addNodes(defs: NodeDef[]): void;
-    /**
-     * Remove a pending node. Cannot remove running or completed nodes.
-     * Removes all edges incident to this node.
-     */
-    removeNode(id: string): void;
-    /** Add one dependency edge atomically. Only work that has not started may gain prerequisites. */
-    addDependency(from: string, to: string): void;
-    /** Remove one dependency edge. Completed/running work remains immutable. */
-    removeDependency(from: string, to: string): void;
-    /**
-     * 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. */
-    /**
-     * Merge patch into node.params. Allowed while the node is pending OR failed.
-     *
-     * "failed" is included because that is exactly when the leader refines a task: the node is not
-     * executing, and retryNode resets it to pending anyway, so the patch lands on the DAG that gets
-     * checkpointed. Holding such patches outside the node instead (a per-call scratch map) meant a
-     * refinement made in one consultation was gone by the next, and the retry re-ran the failing text.
-     */
-    updateNodeParams(id: string, patch: Record<string, unknown>): void;
-    /** Add an explicit edge. Validates no cycle. Validates ports exist on source. */
-    addEdge(edge: Edge): void;
-    removeEdge(from: string, to: string, fromPort?: string): void;
-    serialize(): SerializedNode[];
-    /**
-     * Restore status from persisted snapshot.
-     * Running nodes become pending (need re-execution after crash).
-     * 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. */
-    private edgeDead;
-    private incomingForwardEdges;
-    private isBlockedByFailed;
-    /** A pending node is "skippable" if all its forward edges are dead. */
-    private isSkippable;
-    /**
-     * §3.2 Skip propagation.
-     * After markCompleted/markFailed/markSkipped, repeatedly mark pending nodes
-     * whose incoming edges are all dead as skipped.
-     * Product mode (no conditional edges) → no-op.
-     */
-    private propagateSkips;
-    /**
-     * §3.3 Reset all loop-body nodes back to pending for next iteration.
-     */
-    private resetLoopScope;
-    /**
-     * Compute the loop body: nodes reachable from the loop controller's "loop" outPort
-     * via non-loopBack forward edges, up to (but not including) the loop controller itself.
-     * The controller's "done" port leads OUT of the loop and is not part of the body.
-     */
-    private loopBodyNodes;
-    private validateDag;
-    private requireNode;
-}
-export interface SerializedNode {
-    id: string;
-    kind: string;
-    params: Record<string, unknown>;
-    dependsOn: string[];
-    outPorts: string[];
-    joinPolicy: "all" | "any";
-    status: NodeStatus;
-    firedPorts?: string[];
-    output?: unknown;
-    error?: string;
-    startedAt?: number;
-    completedAt?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    changedFiles?: string[];
-    acceptanceUnverified?: boolean;
-    runIndex: number;
-    maxIterations?: number;
-    iteration?: number;
-}

package/dist/types/orchestration/delegate-approval-policy.d.ts

@@ -1,8 +0,0 @@
-/**
- * Unattended orchestration runs are explicitly launched by the user and already inherit the
- * Host-projected permission scope. Approve only the current operation; never widen the persisted
- * permission policy. If the provider cannot offer a one-shot approval, fail closed.
- */
-export declare function selectUnattendedApprovalOptionId(options: Array<Record<string, unknown>>): string;
-/** Planning-only delegates must never execute tools; answer explicitly so the provider cannot hang. */
-export declare function selectPlanningRejectionOptionId(options: Array<Record<string, unknown>>): string;

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

@@ -1,8 +0,0 @@
-import type { DelegateRequestParams, SupervisorEventSink, TurnResult } from "../host-contract/index.js";
-/** Authority-neutral transport used by the six orchestration stations to call Gateway-owned workers. */
-export interface DelegateBridge {
-    isSupported(): boolean;
-    send(params: DelegateRequestParams, sink: SupervisorEventSink): Promise<TurnResult>;
-    cancel(delegationId: string): void;
-    respond(delegationId: string, approvalId: string, optionId: string): void;
-}

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

@@ -1,17 +0,0 @@
-import type { AcceptanceChecklist, AcceptanceCriterion, AcceptanceEvidence, AcceptanceStatus } from "./goal-run-types.js";
-/** Return a NEW checklist with one criterion's status flipped. Never mutates the input.
- *  Monotonicity contract: a criterion that already `passed` may only revert to `failed` via a
- *  deterministic verify REGRESSION (allowRegression=true). Any other downgrade of a passed criterion
- *  (an LLM judge's prose verdict, a re-pending) is IGNORED — `passed` is terminal except when its own
- *  `verify` command starts failing. This is what makes "no regression goes unnoticed" hold without
- *  letting assessment flap: real regressions are caught (verify), spurious ones are rejected. */
-export declare function flipCriterionStatus(checklist: AcceptanceChecklist, criterionId: string, status: AcceptanceStatus, evidence?: AcceptanceEvidence[], reason?: string, allowRegression?: boolean): AcceptanceChecklist;
-/** Done iff every criterion is passed or superseded (none pending/failed). */
-export declare function isChecklistDone(checklist: AcceptanceChecklist): boolean;
-/** True iff every not-yet-passed/superseded criterion is covered by an unreachable entry. */
-export declare function unreachableCoversRemaining(checklist: AcceptanceChecklist, unreachable: {
-    criterionId: string;
-    reason: string;
-}[]): boolean;
-/** Derive a new immutable checklist version on goal-edit. Dropped criteria -> superseded. */
-export declare function newChecklistVersion(prev: AcceptanceChecklist, nextCriteria: Pick<AcceptanceCriterion, "id" | "criterion" | "verify" | "evidenceSource">[]): AcceptanceChecklist;

package/dist/types/orchestration/goal-context-envelope.d.ts

@@ -1,7 +0,0 @@
-import type { ContextEnvelope } from "../protocol/wire/chat-types.js";
-import type { PersistedGoalRunState, PhaseSpec } from "./goal-run-types.js";
-/**
- * Project the Host-owned Goal checkpoint into bounded Agent-local compaction facts.
- * The envelope is regenerated for every leader/worker turn; it never becomes a second Goal owner.
- */
-export declare function buildGoalContextEnvelope(state: PersistedGoalRunState, operation: string, spec?: PhaseSpec): ContextEnvelope;