qlogicagent 2.24.1 → 2.24.2

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

@@ -1,151 +0,0 @@
-import { type HostRunStateAuthority } from "./run-state-host-authority.js";
-import type { ContextEnvelope } from "../protocol/wire/chat-types.js";
-import type { ProductFailureAssigneeSelection } from "./agent-instance.js";
-import { type AcceptanceChecklist, type AcceptanceDelta, type GoalInstructionKind, type GoalMilestone, type GoalQueuedMessage, type GoalTaskProjection, type GoalSpec, type GoalTurnContext, type PersistedGoalRunState, type PhaseSpec } from "./goal-run-types.js";
-export interface LeaderPort {
-    /** Reapply the durable user turn policy before any leader call, including crash recovery. */
-    setTurnContext?(context: GoalTurnContext | undefined): void;
-    /** Re-ground the native leader's own compaction state in canonical Host Goal facts. */
-    setContextEnvelope?(context: ContextEnvelope | undefined): void;
-    selectHandoffCandidate(input: ProductFailureAssigneeSelection): Promise<string | undefined>;
-    draftGoalSpec(goal: string, revisionFeedback: GoalQueuedMessage[], revision: number): Promise<GoalSpec>;
-    planPhase(goalSpec: GoalSpec, summary: string, drained: GoalQueuedMessage[], checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
-    critiquePlan(spec: PhaseSpec, goalSpec: GoalSpec, checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
-    assess(productId: string, goalSpec: GoalSpec, checklist: AcceptanceChecklist, milestones?: GoalMilestone[], agentPool?: string[]): Promise<{
-        deltas: AcceptanceDelta[];
-        producedFiles: boolean;
-        tasks?: GoalTaskProjection[];
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-        };
-    }>;
-    compact(prevSummary: string, deltas: AcceptanceDelta[]): Promise<string>;
-}
-export interface PhaseRunnerPort {
-    startBoundedProductPhase(spec: PhaseSpec, agentPool: string[], cwd: string, opts: {
-        signal: AbortSignal;
-        onProductId: (productId: string) => void;
-        budget?: {
-            maxTotalTokens?: number;
-            maxDuration?: number;
-        };
-        turnContext?: GoalTurnContext;
-        contextEnvelope?: ContextEnvelope;
-    }): Promise<{
-        productId: string;
-        result: string;
-    }>;
-    resumePhase(productId: string, opts: {
-        signal: AbortSignal;
-        cwd: string;
-        phaseStartMs: number;
-    }): Promise<{
-        result: string;
-    }>;
-    /** Interrupt a persisted in-flight Product when the control RPC cannot see the original AbortController. */
-    pausePhase?(productId: string): Promise<void>;
-}
-export type GoalNotifier = (method: string, payload: Record<string, unknown>) => void;
-export interface GoalLoopCoordinatorDeps {
-    leader: LeaderPort;
-    runner: PhaseRunnerPort;
-    cwd: string;
-    projectId: string;
-    canonicalSessionId: string;
-    leaderAgentId: string;
-    runStateAuthority?: HostRunStateAuthority;
-    notify?: GoalNotifier;
-    log?: {
-        warn(message: string): void;
-    };
-}
-export declare class GoalLoopCoordinator {
-    private readonly deps;
-    private seq;
-    private opChain;
-    private activePhase;
-    private readonly persistenceContext;
-    constructor(deps: GoalLoopCoordinatorDeps);
-    private serialize;
-    private notify;
-    private append;
-    private persist;
-    private transitionStage;
-    /** Durably reserve a goal-run without entering the leader lane. Returns the goalRunId immediately. */
-    start(goal: string, agentPool: string[], budget?: {
-        maxTotalTokens?: number;
-        maxDurationMs?: number;
-    }, turnContext?: GoalTurnContext): Promise<string>;
-    private startImpl;
-    private goalSpecConfirmationMessage;
-    private ensureGoalSpecImpl;
-    private ensureChecklistInitializedImpl;
-    private hydrate;
-    /** Load the run; seed `seq` so a fresh instance (post-crash) keeps appending monotonically. */
-    private load;
-    enqueueMessage(goalRunId: string, text: string, kind?: GoalInstructionKind): Promise<void>;
-    private enqueueMessageImpl;
-    /** Resolve a structured blocker and resume in one serialized mutation. A UI or IM client must not
-     * coordinate message + resume as two RPCs because a transport failure between them duplicates the
-     * answer or leaves the blocker visible after execution has continued. */
-    answerBlocker(goalRunId: string, text: string): Promise<PersistedGoalRunState>;
-    /** Run exactly one phase. Returns the updated state. */
-    runOnePhase(goalRunId: string): Promise<PersistedGoalRunState>;
-    private runOnePhaseImpl;
-    /** B: the single phase tail — assess the in-flight/just-finished Product, flip the checklist, compact
-     *  the summary, append phase_assessed/progress_compacted/phase_boundary, advance phaseIndex, clear the
-     *  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;
-    private planPhaseWithRetry;
-    private recordPhasePlan;
-    private block;
-    /** 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;
-    /** #4: classify how an in-flight phase's throw should land. A user pause aborts the signal (whatever
-     *  error then surfaces → "user_pause"); the adapter's phase wall throws an AbortError
-     *  WITHOUT the signal being aborted, tagged pauseReason="phase_timeout" (untagged AbortErrors from
-     *  simpler runner ports default to phase_timeout — the only engine-side AbortError source). Anything
-     *  else is a real failure → undefined (the caller honest-FAILs). */
-    private pauseReasonOf;
-    /** I3: true when the loaded state shows a phase that started (currentProductId set) but never reached
-     *  its assessment/boundary — i.e. a process died mid-phase. Inspects the durable event log because
-     *  the snapshot alone can't distinguish "just started" from "started and crashed". */
-    private crashedMidPhase;
-    /** The ms timestamp of the phase_started event for `productId` (when the crashed phase originally began).
-     *  Used as the crash-resume deliverable-capture window so files created before the crash are kept.
-     *  Returns 0 (no lower bound) if not found — capture-all is acceptable for this rare path. */
-    private phaseStartedMs;
-    /** Drive phases until the run ends or is paused. Not serialized: it only calls the serialized
-     *  runOnePhase in a loop, so a concurrent pause/stop is observed at the next boundary. */
-    runToCompletion(goalRunId: string): Promise<PersistedGoalRunState>;
-    private publishRoundMessage;
-    /** Pause: abort the in-flight phase IMMEDIATELY (before serialize) so it drains fast and the mutex
-     *  frees quickly, then persist the paused state. If the in-flight phase is the one being aborted, it
-     *  drains via its abort handler and persists `paused` itself (runOnePhaseImpl's catch); pauseImpl then
-     *  no-ops on the already-paused state. */
-    pause(goalRunId: string): Promise<PersistedGoalRunState>;
-    private pauseImpl;
-    /** Edit the goal while paused and invalidate the prior Spec; execution requires fresh confirmation. */
-    updateGoal(goalRunId: string, newGoal: string): Promise<PersistedGoalRunState>;
-    private updateGoalImpl;
-    /** Resume a paused run; an optional newGoal applies a goal-edit first (reusing updateGoalImpl). */
-    resume(goalRunId: string, newGoal?: string, additionalBudget?: {
-        maxTotalTokens?: number;
-        maxDurationMs?: number;
-    }): Promise<PersistedGoalRunState>;
-    private resumeImpl;
-    /** User stop — ends the run as stopped. The caller stops driving the detached loop. */
-    stop(goalRunId: string): Promise<PersistedGoalRunState>;
-    private stopImpl;
-    private end;
-    private finishTerminal;
-    /** Re-attach a fresh Agent process to a durable active run without changing a user pause. */
-    recover(goalRunId: string): Promise<PersistedGoalRunState>;
-    /** Clear a terminal Goal from the thread-native current-goal projection without deleting its audit log. */
-    dismiss(goalRunId: string): Promise<PersistedGoalRunState>;
-}

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

@@ -1,152 +0,0 @@
-import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-provider-directory.js";
-import type { DelegateBridge } from "./delegate-bridge.js";
-import { type PlannerMemoryContext } from "./planner-memory-brief.js";
-import type { ProductFailureAssigneeSelector, 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";
-export type GoalVerifyCommandValidation = {
-    valid: true;
-} | {
-    valid: false;
-    reason: string;
-};
-/**
- * Persisted Goal verifiers are unattended acceptance contracts, not general-purpose shell scripts.
- * Reject known stdin, interactive, host-specific and nondeterministic constructs before persistence;
- * runVerifyDeltas repeats the check for old snapshots and defense in depth.
- */
-export declare function validateGoalVerifyCommand(command: string): GoalVerifyCommandValidation;
-export declare function validateGoalVerifyCommandInWorkspace(command: string, cwd: string): GoalVerifyCommandValidation;
-/**
- * #2 verify 输出的头尾截断:测试/构建命令的失败摘要通常在输出**末尾**(框架的 summary 行),裸
- * slice(0,N) 保头丢尾会把真正的失败原因截掉,判官只能看到无关的开头。超限时保留头尾各半,并在
- * 中间插入可见的省略注记(对齐 ASSESS 路径 "…(已截断)" 的风格 —— 截断必须留痕,不静默)。
- */
-export declare function capVerifyOutput(text: string, cap?: number): string;
-/**
- * Deterministic runtime verification — the cc/codex-style "the runner OBSERVES the result" applied to
- * the judge, run EVERY phase as a continuous regression gate (not a one-time entry ticket). For each
- * criterion that carries a `verify` shell command (run in the project workspace):
- *   - FORWARD (pending/failed): exit 0 → a TRUSTED passed delta (bypasses the LLM evidence-gate because
- *     real exit-0 is harder evidence than any LLM citation — closes the gap where a worker runs a test
- *     successfully but its distilled summary can't convince a conservative leader).
- *   - REGRESSION (already passed): re-run it. exit ≠ 0 → a TRUSTED passed→failed regression delta. This
- *     is what stops a later phase from silently breaking an earlier verified deliverable and the run
- *     still declaring `done` ("checklist all green, disk actually broken"). A passing re-check is a no-op.
- * Files accumulate across phases in the same workspace, so without this re-check a regression goes
- * unnoticed; with it, the strongest deterministic check we have doubles as the regression baseline.
- */
-export declare function runVerifyDeltas(criteria: AcceptanceCriterion[], cwd: string, log?: {
-    info?(m: string): void;
-    warn?(m: string): void;
-}): Promise<AcceptanceDelta[]>;
-/**
- * #1 residual regression cover for criteria WITHOUT a `verify` command. Such a criterion passed by citing
- * an evidence file; if that cited file later VANISHES from the project workspace, the deliverable is
- * unambiguously gone → emit a TRUSTED passed→failed regression delta. We only flag DELETION (not
- * modification): a "content contains X" file can be legitimately extended by a later phase, so a content
- * change is ambiguous, but a missing file is not. Verify-backed criteria are handled by runVerifyDeltas;
- * "output"-only citations have no on-disk artifact to check and are skipped.
- */
-export declare function runFileEvidenceRegressionDeltas(criteria: AcceptanceCriterion[], cwd: string, log?: {
-    warn?(m: string): void;
-}): AcceptanceDelta[];
-export declare function recordGoalPhaseChangedFiles(productId: string, cwd: string, phaseStartMs: number): Promise<void>;
-export declare function takeGoalPhaseChangedFiles(productId: string): string[];
-/**
- * Find the first balanced `{...}` or `[...]` in `text` and JSON.parse it. The leader (an LLM) may
- * wrap the JSON in prose or a ```json fence; this scans for the first balanced bracket with
- * string-awareness (braces/brackets inside string values are ignored) so an embedded fence or quote
- * can't truncate the block. Throws if no balanced JSON is found or it won't parse.
- */
-export declare function extractJson<T>(text: string): T;
-export interface LeaderAdapterDeps {
-    /** Resolves the leader's external ACP descriptor (product-planner.ts:583). */
-    providerDirectory: HostAgentProviderDirectory;
-    /** Catalog id of the leader agent (e.g. "qlogicagent"). */
-    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). */
-    goalRunId: string;
-    /** (c) Planning-time memory: ONE search per run + global cheat-sheet into the
-     * checklist/plan prompts. Optional — planning runs without it. */
-    memoryContext?: PlannerMemoryContext;
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-    /** 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;
-    failureAssigneeSelector: ProductFailureAssigneeSelector;
-    /** Optional per-phase budget passed through to ProductOrchestrator.create. */
-    budget?: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-    };
-    /** Poll interval (ms) while awaiting phase completion. Default 2000. */
-    pollIntervalMs?: number;
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-export declare function createPhaseRunnerAdapter(deps: PhaseRunnerAdapterDeps): PhaseRunnerPort;
-export declare function parsePhaseSpec(reply: string, availableAgentIds: string[], log?: {
-    warn?(m: string): void;
-}): PhaseSpec;
-/**
- * B (evidence-gating): goal-mode's assess() is the SOLE acceptance authority (Product's per-task judge
- * is a no-op for a session-less goal-mode run), so a criterion may only flip to `passed` when it is
- * backed by CITED PRIMARY EVIDENCE — not a bare "PASS". This is the pure decision the LLM cannot be
- * trusted to self-enforce; it's unit-tested independently of the live judge call.
- *
- * Rules:
- *   - `passed` delta: keep only evidence items with a non-empty `source` AND non-empty `quote`, AND
- *     whose `source` is PRIMARY — i.e. it matches one of the run's actual `changedFiles` (exact or
- *     basename/suffix match, since the judge may cite a relative path) OR is the literal `"output"`.
- *     If, after filtering, a passed delta has zero evidence items, do NOT flip it — demote it to a
- *     VISIBLE `pending` note delta (#1③: it reaches the phase_assessed event, the progress summary and
- *     the next phase's "受阻原因", instead of vanishing with only an engine log line).
- *   - `failed` / other deltas: kept as-is (their reason is informational; failed needs no evidence).
- */
-export declare function validateAssessDeltas(rawDeltas: AcceptanceDelta[], changedFiles: string[], log?: {
-    warn(msg: string): void;
-}, context?: {
-    criteria?: AcceptanceCriterion[];
-    outputTexts?: string[];
-    assignmentReceiptLines?: string[];
-    requiredAssignmentAgentIds?: string[];
-}): AcceptanceDelta[];
-/**
- * A Host assignment criterion accepts the Goal's selected worker pool, not merely one authentic
- * receipt. Re-check coverage every phase so a prematurely persisted pass regresses after recovery.
- */
-export declare function runAssignmentEvidenceCoverageDeltas(criteria: AcceptanceCriterion[], assignmentReceiptLines: string[], requiredAgentIds: string[], log?: {
-    warn(msg: string): void;
-}): AcceptanceDelta[];
-/**
- * #1②: the judge-prompt view of this phase's project changed files. The PROMPT is windowed to stay
- * bounded, but the truncation is DISCLOSED in-band — a hidden remainder must not read as "没有更多改动"
- * (and the whitelist gate in assess() always uses the untruncated set, so citing an unlisted-but-real
- * file still counts as primary evidence).
- */
-export declare const ASSESS_FILES_WINDOW = 50;
-export declare function buildProjectFilesBlock(allFiles: string[], window?: number): string;
-/** Build the evidence block for the judge from a live Product status (task outputs + changed files).
- *  Exported for the #3 regression test: the >ASSESS_MAX_TASKS window note must never silently vanish. */
-export declare function buildEvidenceBlock(status: ReturnType<ProductOrchestrator["getStatus"]>): string;
-export declare const ASSESS_ASSIGNMENT_HISTORY_WINDOW = 60;
-export declare function buildGoalAssignmentHistoryBlock(allLines: string[], window?: number): string;

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

@@ -1,21 +0,0 @@
-import type { GoalRunEvent, PersistedGoalRunState } from "./goal-run-types.js";
-import type { HostRunStateAuthority } from "./run-state-host-authority.js";
-import { type ThreadItemEvent } from "../host-contract/index.js";
-export interface GoalPersistenceContext {
-    projectId: string;
-    canonicalSessionId: string;
-    authority: HostRunStateAuthority;
-}
-/** Build the sole live-and-durable representation of a Goal fact. */
-export declare function toGoalThreadItemEvent(goalRunId: string, event: GoalRunEvent, context: GoalPersistenceContext): ThreadItemEvent;
-/** Append one canonical item to the Gateway-owned durable RunState event log. */
-export declare function appendGoalRunEvent(goalRunId: string, event: GoalRunEvent, context: GoalPersistenceContext): Promise<ThreadItemEvent>;
-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>;
-/** Apply events newer than the checkpoint cursor. This closes the append→checkpoint crash window
- * without introducing a second journal or compatibility reader: Host events.jsonl remains the single
- * durable fact stream, and the checkpoint remains its replaceable projection. */
-export declare function replayGoalRunEvents(state: PersistedGoalRunState, events: GoalRunEvent[]): PersistedGoalRunState;
-/** 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

@@ -1,225 +0,0 @@
-/** Loop tunables (single source of truth — I9). */
-export declare const GOAL_NO_PROGRESS_LIMIT = 3;
-export declare const GOAL_SOFT_NO_PROGRESS_LIMIT = 8;
-export declare const GOAL_PHASE_TIMEOUT_MS: number;
-export declare const GOAL_UNREACHABLE_MIN_STREAK = 2;
-export type GoalRunStatus = "running" | "blocked" | "ended";
-export type GoalPauseState = "running" | "draining" | "paused";
-/** Why a run is paused; the canonical paused item keeps engine and user intent distinguishable. */
-export type GoalPauseReason = "user_pause" | "phase_timeout";
-export type GoalEndReason = "done" | "stopped" | "failed";
-export type AcceptanceStatus = "pending" | "passed" | "failed" | "superseded";
-export type GoalSpecStatus = "drafting" | "awaiting_clarification" | "awaiting_confirmation" | "confirmed";
-export type GoalStageName = "drafting_spec" | "initializing_checklist" | "planning_phase" | "reviewing_plan" | "executing_tasks" | "assessing_results" | "compacting_progress" | "recovering";
-/** Durable, user-safe activity projection. It exposes what is happening without leaking reasoning. */
-export interface GoalStage {
-    stage: GoalStageName;
-    phaseIndex: number;
-    agentId: string;
-    role: GoalControlRole | "worker_team" | "system";
-    startedAt: string;
-    detail?: string;
-}
-export type GoalInstructionKind = "instruction_once" | "constraint_add" | "constraint_remove" | "answer_to_blocker" | "priority_change";
-export type GoalTaskStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "superseded";
-export type GoalControlRole = "leader" | "planner" | "plan_critic" | "acceptance_judge";
-export type GoalExecutionRole = "implementer" | "tester" | "reviewer" | "integrator";
-export type GoalAgentRole = GoalControlRole | GoalExecutionRole;
-export interface GoalTaskProjection {
-    taskId: string;
-    assignee: string;
-    prompt: string;
-    dependsOn?: string[];
-    acceptanceCriteria?: string;
-    status: GoalTaskStatus;
-    result?: string;
-    error?: string;
-    inputTokens?: number;
-    outputTokens?: number;
-    changedFiles?: string[];
-}
-export interface GoalRoleProjection {
-    name: string;
-    role: GoalAgentRole;
-    agentId: string;
-}
-export interface GoalMilestone {
-    phaseIndex: number;
-    label: string;
-    status: "planned" | "running" | "completed" | "failed" | "blocked";
-    productId?: string;
-    tasks: GoalTaskProjection[];
-    roles: GoalRoleProjection[];
-}
-export interface GoalBlocker {
-    code: string;
-    message: string;
-    phaseIndex?: number;
-    taskId?: string;
-    askId?: string;
-    questions?: Array<{
-        id: string;
-        prompt: string;
-    }>;
-    createdAt: string;
-}
-export interface GoalBudget {
-    maxTotalTokens?: number;
-    maxDurationMs?: number;
-    inputTokens: number;
-    outputTokens: number;
-}
-/**
- * Execution choices captured when the user starts a Goal. They are durable so a recovered
- * driver uses the same model/permission/skill policy instead of silently falling back to defaults.
- */
-export interface GoalTurnContext {
-    modelId?: string;
-    reasoningEffort?: string;
-    permissions?: unknown;
-    activeSkills?: string[];
-}
-/** The single user-confirmed authority for planning, execution and acceptance. */
-export interface GoalSpec {
-    revision: number;
-    objective: string;
-    /** Canonical execution boundary confirmed by the user with the rest of the GoalSpec. */
-    workspaceMutationPolicy: "forbid" | "allow";
-    inScope: string[];
-    outOfScope: string[];
-    constraints: string[];
-    assumptions: string[];
-    acceptanceCriteria: AcceptanceCriterion[];
-    verificationStrategy: string[];
-    openQuestions: Array<{
-        id: string;
-        prompt: string;
-    }>;
-}
-export interface GoalFinalReport {
-    outcome: GoalEndReason;
-    summary: string;
-    acceptanceChecklist: AcceptanceChecklist;
-    milestones: GoalMilestone[];
-    changedFiles: string[];
-    inputTokens: number;
-    outputTokens: number;
-    wallClockStartedAt: string;
-    finishedAt: string;
-    failedReason?: string;
-}
-/** FINAL evidence type (I9 — not staged). source = file path / check name; quote = cited excerpt. */
-export interface AcceptanceEvidence {
-    source: string;
-    quote: string;
-}
-export interface AcceptanceCriterion {
-    id: string;
-    criterion: string;
-    status: AcceptanceStatus;
-    /** Output-only criteria (reply/copy/summary/etc.) are accepted from the Product task result text,
-     *  never by inventing a shell verifier or citing an unrelated file. */
-    evidenceSource?: "output" | "host.product.assignment";
-    evidence?: AcceptanceEvidence[];
-    reason?: string;
-    verify?: string;
-}
-export interface AcceptanceChecklist {
-    version: number;
-    criteria: AcceptanceCriterion[];
-}
-/** A bounded phase plan (a subset of the Product plan). */
-export interface PhaseSpec {
-    phaseLabel: string;
-    tasks: {
-        taskId: string;
-        assignee: string;
-        prompt: string;
-        workspaceMutation: "none" | "required";
-        dependsOn?: string[];
-        acceptanceCriteria?: string;
-    }[];
-    instances: {
-        name: string;
-        role: GoalExecutionRole;
-        agentId: string;
-    }[];
-    controlRoles?: GoalRoleProjection[];
-    reasoning?: string;
-    unreachable?: {
-        criterionId: string;
-        reason: string;
-    }[];
-    /** fail-open 打标:critique 判官坏 JSON 重试后仍失败,本计划未经精修直接执行。 */
-    critiqueSkipped?: boolean;
-    /** 截断收据:超 MAX_TASKS_PER_PHASE 被丢弃的任务数(其对应标准仍未通过,下一阶段会重新规划)。 */
-    droppedTaskCount?: number;
-}
-/** Output of assess() — one per criterion the phase touched. */
-export interface AcceptanceDelta {
-    criterionId: string;
-    oldStatus: AcceptanceStatus;
-    newStatus: AcceptanceStatus;
-    evidence?: AcceptanceEvidence[];
-    reasonIfFailed?: string;
-    regression?: boolean;
-}
-export interface GoalQueuedMessage {
-    id: string;
-    ts: string;
-    text: string;
-    kind: GoalInstructionKind;
-}
-/** Append-only event (events.jsonl). seq is monotonic from 1. */
-export interface GoalRunEvent {
-    seq: number;
-    ts: string;
-    type: "goal_started" | "goal_spec_drafted" | "blocker_answered" | "checklist_initialized" | "phase_planned" | "phase_started" | "phase_assessed" | "progress_compacted" | "goal_edited" | "message_queued" | "blocked" | "paused" | "resumed" | "stopped" | "phase_boundary" | "round_message" | "budget_updated" | "stage_changed" | "recovery_failed" | "final_report" | "dismissed" | "recovered" | "ended";
-    payload: Record<string, unknown>;
-}
-/** Goal checkpoint stored by Gateway RunState and advanced by replaying later Host events. */
-export interface PersistedGoalRunState {
-    goalRunId: string;
-    projectId: string;
-    canonicalSessionId: string;
-    leaderAgentId: string;
-    originalGoal: string;
-    currentGoal: string;
-    goalSpecStatus: GoalSpecStatus;
-    goalSpec?: GoalSpec;
-    goalUpdatedAt?: string;
-    checklistVersion: number;
-    /** False only between the durable start acknowledgement and the detached leader initialization. */
-    checklistInitialized: boolean;
-    status: GoalRunStatus;
-    pauseState: GoalPauseState;
-    phaseIndex: number;
-    noProgressCount: number;
-    noFlipStreak: number;
-    unreachableStreak: Record<string, number>;
-    progressSummary: string;
-    currentStage?: GoalStage;
-    /** Timestamp of the latest durable Goal activity, used by every surface to judge freshness. */
-    lastActivityAt?: string;
-    acceptanceChecklist: AcceptanceChecklist;
-    queuedMessages: GoalQueuedMessage[];
-    /** Durable constraints are re-grounded into every later phase until explicitly removed. */
-    constraints: GoalQueuedMessage[];
-    agentPool: string[];
-    milestones: GoalMilestone[];
-    budget: GoalBudget;
-    turnContext?: GoalTurnContext;
-    blocker?: GoalBlocker;
-    finalReport?: GoalFinalReport;
-    dismissedAt?: string;
-    wallClockStartedAt: string;
-    pausedAt?: string;
-    /** How the run became paused (user_pause / phase_timeout) — cleared on resume. */
-    pauseReason?: GoalPauseReason;
-    stopReason?: string;
-    endReason?: GoalEndReason;
-    failedReason?: string;
-    currentProductId?: string;
-    projectWorkspaceDir: string;
-    lastEventSeq: number;
-}

package/dist/types/orchestration/planner-memory-brief.d.ts

@@ -1,39 +0,0 @@
-/**
- * Memory context for long-run orchestration (Product / goal-mode / Solo).
- *
- * Two deliberately different depths — the design decision is graduated, not
- * uniform (worker 每轮召回被否决:杂讯+成本×成员×轮数+破坏验收可复现):
- *   (a) EVERY member dispatch carries the owner's global cheat-sheet — the
- *       2KB baseline (language, boundaries, style) any executor must honor.
- *       Self-hosted qlogicagent workers already inject it per-turn; this
- *       covers third-party workers and is harmlessly redundant otherwise.
- *   (c) The LEADER does ONE memory search at planning time (run-scoped) and
- *       carries the hits into checklist derivation + phase planning — long
- *       tasks plan once and execute many turns, so retrieval belongs to the
- *       planning step, not the execution loop.
- *
- * Everything here is injected (no direct skills import from orchestration);
- * the cli wiring supplies readUserIndexForPrompt + provider.search.
- */
-export interface PlannerMemoryContext {
-    /** Owner-level global INDEX (cheat-sheet). Null when absent. */
-    globalIndex(): string | null;
-    /** One-shot L2 search (goal text as query). Optional — planning must run without it. */
-    search?(query: string): Promise<Array<{
-        text: string;
-    }>>;
-}
-export interface PlannerMemoryLog {
-    warn(msg: string): void;
-}
-/**
- * (c) Planning-time brief: global cheat-sheet + goal-relevant L2 hits.
- * Returns "" when there is nothing — callers splice it in only when non-empty.
- * A failed search degrades to cheat-sheet-only WITH a trace (never silently).
- */
-export declare function buildPlannerMemoryBrief(ctx: PlannerMemoryContext | undefined, goal: string, log?: PlannerMemoryLog): Promise<string>;
-/**
- * (a) Worker dispatch preamble: cheat-sheet only, no retrieval.
- * Returns "" when the owner has no global layer yet.
- */
-export declare function buildWorkerMemoryPreamble(ctx: PlannerMemoryContext | undefined, log?: PlannerMemoryLog): string;