qlogicagent 2.16.5 → 2.16.7

package/dist/types/cli/handlers/working-materials-handler.d.ts

@@ -0,0 +1,9 @@
+import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+export interface WorkingMaterialsHandlerHost {
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+export declare function handleWorkingMaterialsGet(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkingMaterialsReplace(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkingMaterialsUpsert(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkingMaterialsRemove(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkingMaterialsReorder(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/idle-dream-coordinator.d.ts

@@ -28,6 +28,12 @@ export interface IdleDreamCoordinatorOptions {
         sessionId: string;
     }>>;
     runDream(message: AgentRpcRequest): Promise<void>;
+    /**
+     * Optional idle-time hook run on every idle fire BEFORE the dream gates (so it is not blocked by
+     * dream cooldown / missing LLM transport). Used for the feedback redaction+upload sweep
+     * (design §9 item 5). Errors are swallowed so a sweep failure never breaks dream.
+     */
+    onIdle?(): Promise<void>;
 }
 export declare class IdleDreamCoordinator {
     private readonly options;

package/dist/types/cli/mcp-bootstrap.d.ts

@@ -13,6 +13,7 @@ export interface McpBootstrapDeps {
 }
 export declare const mcpToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<McpBootstrapDeps>;
 export declare function configureMcpBootstrap(deps: McpBootstrapDeps): void;
+export declare function readUserMcpConfig(pathService: PathService, log?: RuntimeLogger): unknown;
 export declare function buildMcpBootstrapEntries(params: {
     turnMcpConfig?: unknown;
     userMcpConfig?: unknown;

package/dist/types/cli/rpc-registry.d.ts

@@ -12,7 +12,10 @@ import { type ProjectHandlerHost } from "./handlers/project-handler.js";
 import { type SessionHandlerHost } from "./handlers/session-handler.js";
 import { type SettingsHandlerHost } from "./handlers/settings-handler.js";
 import { type SkillsHandlerHost } from "./handlers/skills-handler.js";
+import { type TurnBaselineHandlerHost } from "./handlers/turn-baseline-handler.js";
+import { type MessageFeedbackHandlerHost } from "./handlers/message-feedback-handler.js";
 import { type TurnControlHandlerHost } from "./handlers/turn-handler.js";
+import { type WorkingMaterialsHandlerHost } from "./handlers/working-materials-handler.js";
 import { type DreamHandlerHost } from "./handlers/dream-handler.js";
 import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
 export type RpcMethodHandler = (msg: AgentRpcRequest) => void;
@@ -48,6 +51,9 @@ export interface RpcHandlerHosts {
     settings: SettingsHandlerHost;
     dream: DreamHandlerHost;
     turn: TurnControlHandlerHost;
+    turnBaseline: TurnBaselineHandlerHost;
+    messageFeedback: MessageFeedbackHandlerHost;
+    workingMaterials: WorkingMaterialsHandlerHost;
     /** agents/solo/product are served by the multi-agent sub-host. */
     multiAgent: MultiAgentHandlerHost;
     /**

package/dist/types/cli/skill-invocation-service.d.ts

@@ -2,5 +2,7 @@ export interface RunSkillInvocationParams {
     skillName: string;
     skillContent: string;
     userArgs?: string;
+    skillDir?: string;
+    sessionId?: string;
 }
 export declare function runSkillInvocation(params: RunSkillInvocationParams): Promise<string>;

package/dist/types/cli/stdio-rpc-handler-hosts.d.ts

@@ -2,6 +2,7 @@ import type { LLMRequest } from "../agent/types.js";
 import type { ModelPurpose } from "../runtime/infra/model-registry.js";
 import type { RpcHandlerHosts } from "./rpc-registry.js";
 type DirectStdioRpcHost = RpcHandlerHosts["config"] & RpcHandlerHosts["control"] & RpcHandlerHosts["files"] & RpcHandlerHosts["skills"] & RpcHandlerHosts["project"] & RpcHandlerHosts["community"] & RpcHandlerHosts["settings"] & RpcHandlerHosts["petConfirm"] & {
+    currentTurnId?: string;
     readonly multiAgentHandlerHost: RpcHandlerHosts["multiAgent"];
     readonly workflowHandlerHost: RpcHandlerHosts["workflow"];
 };

package/dist/types/cli/stdio-runtime-bootstrap.d.ts

@@ -6,6 +6,7 @@ export interface StdioRuntimeBootstrapDeps {
     verbose: boolean;
     getActiveProjectRoot(): string;
     getCurrentSessionId?(): string | undefined;
+    getCurrentTurnId?(): string | undefined;
     resolveClientForPurpose(purpose: ModelPurpose): {
         transport: LLMTransport;
         apiKey: string;

package/dist/types/cli/tool-bootstrap-core-registration.d.ts

@@ -11,6 +11,7 @@ export interface LocalCoreToolRegistrationContext {
     backgroundTaskRuntime: BackgroundTaskManager | null;
     getBackgroundTaskRuntime?: () => BackgroundTaskManager | null;
     getTaskScopeKey?: () => string | undefined;
+    getCurrentTurnId?: () => string | undefined;
     askUserCallback: ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null;
     getAskUserCallback?: () => ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null;
     onExecProgress?: (progress: ExecProgress) => void;

package/dist/types/cli/tool-bootstrap.d.ts

@@ -52,6 +52,7 @@ export interface BootstrapConfig {
         model: string;
     } | null;
     getTaskScopeKey?(): string | undefined;
+    getCurrentTurnId?(): string | undefined;
 }
 /**
  * Create all locally-executable tools and install into centralized tool pool.

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

@@ -732,6 +732,14 @@ export type FilesCreateParams = GatewayRpcMethodMap["files.create"]["params"];
 export type FilesCreateResult = GatewayRpcMethodMap["files.create"]["result"];
 export type FilesRenameParams = GatewayRpcMethodMap["files.rename"]["params"];
 export type FilesRenameResult = GatewayRpcMethodMap["files.rename"]["result"];
+export type FilesMoveParams = GatewayRpcMethodMap["files.move"]["params"];
+export type FilesMoveResult = GatewayRpcMethodMap["files.move"]["result"];
+export type FilesCopyParams = GatewayRpcMethodMap["files.copy"]["params"];
+export type FilesCopyResult = GatewayRpcMethodMap["files.copy"]["result"];
+export type FilesSearchParams = GatewayRpcMethodMap["files.search"]["params"];
+export type FilesSearchResult = GatewayRpcMethodMap["files.search"]["result"];
+export type FilesUndoOperationParams = GatewayRpcMethodMap["files.undoOperation"]["params"];
+export type FilesUndoOperationResult = GatewayRpcMethodMap["files.undoOperation"]["result"];
 export type FilesDeleteParams = GatewayRpcMethodMap["files.delete"]["params"];
 export type FilesDeleteResult = GatewayRpcMethodMap["files.delete"]["result"];
 export type FilesGitStatusParams = GatewayRpcMethodMap["files.gitStatus"]["params"];
@@ -1144,6 +1152,22 @@ export interface RpcMethodMap {
         params: FilesRenameParams;
         result: FilesRenameResult;
     };
+    "files.move": {
+        params: FilesMoveParams;
+        result: FilesMoveResult;
+    };
+    "files.copy": {
+        params: FilesCopyParams;
+        result: FilesCopyResult;
+    };
+    "files.search": {
+        params: FilesSearchParams;
+        result: FilesSearchResult;
+    };
+    "files.undoOperation": {
+        params: FilesUndoOperationParams;
+        result: FilesUndoOperationResult;
+    };
     "files.delete": {
         params: FilesDeleteParams;
         result: FilesDeleteResult;

package/dist/types/protocol/wire/agent-events.d.ts

@@ -13,7 +13,7 @@
  * Turn-lifecycle events relayed to the Control UI WebSocket.
  * These are the "chat session" events that every UI client needs.
  */
-export declare const AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested"];
+export declare const AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested"];
 /**
  * Agent Team events (Solo Mode, Product Mode, Plan lifecycle).
  * Relayed to the UI's team/orchestration panel.
@@ -23,7 +23,7 @@ export declare const AGENT_TEAM_WS_EVENT_NAMES: readonly ["solo.progress", "solo
  * All agent notifications that Gateway should relay to WS clients.
  * Union of session events + team events.
  */
-export declare const ALL_AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested", "solo.progress", "solo.specProgress", "solo.agentDelta", "solo.agentActivity", "solo.agentUsage", "solo.evaluation", "product.taskStarted", "product.taskOutput", "product.members", "product.agentActivity", "product.taskCompleted", "product.taskFailed", "product.budgetUpdate", "product.budgetWarning", "product.checkpointed", "product.completed", "product.dagTopology", "plan.interrupted", "goal.run_state_changed", "goal.phase_boundary", "goal.goal_edited", "goal.message_queued", "goal.acceptance_updated"];
+export declare const ALL_AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested", "solo.progress", "solo.specProgress", "solo.agentDelta", "solo.agentActivity", "solo.agentUsage", "solo.evaluation", "product.taskStarted", "product.taskOutput", "product.members", "product.agentActivity", "product.taskCompleted", "product.taskFailed", "product.budgetUpdate", "product.budgetWarning", "product.checkpointed", "product.completed", "product.dagTopology", "plan.interrupted", "goal.run_state_changed", "goal.phase_boundary", "goal.goal_edited", "goal.message_queued", "goal.acceptance_updated"];
 /** Type-level event name for session events. */
 export type AgentWsEventName = (typeof AGENT_WS_EVENT_NAMES)[number];
 /** Type-level event name for team events. */

package/dist/types/protocol/wire/gateway-rpc.d.ts

@@ -408,13 +408,71 @@ export interface GatewayRpcMethodMap {
             newPath?: string;
         };
     };
+    "files.move": {
+        params: {
+            projectId: string;
+            sourcePath: string;
+            targetDir: string;
+            conflictStrategy?: "error" | "keepBoth" | "replace" | "skip";
+        };
+        result: {
+            ok: boolean;
+            newPath?: string;
+            operationId?: string;
+            movedFrom?: string;
+            movedTo?: string;
+            skipped?: string[];
+        };
+    };
+    "files.copy": {
+        params: {
+            projectId: string;
+            sourcePath: string;
+            targetDir: string;
+            conflictStrategy?: "error" | "keepBoth" | "replace" | "skip";
+        };
+        result: {
+            ok: boolean;
+            newPath?: string;
+            operationId?: string;
+            createdPaths?: string[];
+            skipped?: string[];
+        };
+    };
+    "files.undoOperation": {
+        params: {
+            projectId: string;
+            operationId: string;
+        };
+        result: {
+            ok: boolean;
+        };
+    };
     "files.delete": {
         params: {
             projectId: string;
             path: string;
+            mode?: "trash" | "permanent";
         };
         result: {
             ok: boolean;
+            operationId?: string;
+            trashed?: boolean;
+        };
+    };
+    "files.search": {
+        params: {
+            projectId: string;
+            query: string;
+            limit?: number;
+        };
+        result: {
+            matches: Array<{
+                name: string;
+                path: string;
+                type: "file" | "directory";
+            }>;
+            truncated: boolean;
         };
     };
     "files.gitStatus": {
@@ -428,6 +486,108 @@ export interface GatewayRpcMethodMap {
             }>;
         };
     };
+    "turnBaseline.getSummary": {
+        params: {
+            projectId: string;
+            turnId: string;
+        };
+        result: {
+            summary: unknown | null;
+        };
+    };
+    "turnBaseline.getFileDiff": {
+        params: {
+            projectId: string;
+            turnId: string;
+            path: string;
+        };
+        result: {
+            path: string;
+            previousPath?: string;
+            status: string;
+            original: string;
+            modified: string;
+            language?: string;
+            additions?: number;
+            deletions?: number;
+        };
+    };
+    "turnBaseline.listRecent": {
+        params: {
+            projectId: string;
+            sessionId?: string;
+            limit?: number;
+        };
+        result: {
+            summaries: unknown[];
+        };
+    };
+    "turnBaseline.getFileBaseline": {
+        params: {
+            projectId: string;
+            turnId: string;
+            path: string;
+        };
+        result: {
+            path: string;
+            content: string | null;
+            snapshot: unknown | null;
+        };
+    };
+    "workingMaterials.get": {
+        params: {
+            projectId: string;
+            sessionId: string;
+        };
+        result: {
+            items: unknown[];
+            missing: unknown[];
+        };
+    };
+    "workingMaterials.replace": {
+        params: {
+            projectId: string;
+            sessionId: string;
+            items: unknown[];
+        };
+        result: {
+            ok: boolean;
+            items: unknown[];
+        };
+    };
+    "workingMaterials.upsert": {
+        params: {
+            projectId: string;
+            sessionId: string;
+            item: unknown;
+        };
+        result: {
+            ok: boolean;
+            items: unknown[];
+        };
+    };
+    "workingMaterials.remove": {
+        params: {
+            projectId: string;
+            sessionId: string;
+            id: string;
+        };
+        result: {
+            ok: boolean;
+            items: unknown[];
+        };
+    };
+    "workingMaterials.reorder": {
+        params: {
+            projectId: string;
+            sessionId: string;
+            ids: string[];
+        };
+        result: {
+            ok: boolean;
+            items: unknown[];
+        };
+    };
     "skills.list": {
         params: {
             projectId?: string;

package/dist/types/protocol/wire/notification-payloads.d.ts

@@ -81,6 +81,32 @@ export interface TurnRecoveryNotification {
     detail?: string;
     item?: NotificationThreadItem;
 }
+export type TurnFileChangeStatus = "added" | "modified" | "deleted" | "renamed" | "moved" | "copied" | "unchanged";
+export interface TurnFileChangeRecord {
+    path: string;
+    previousPath?: string;
+    status: TurnFileChangeStatus;
+    additions?: number;
+    deletions?: number;
+}
+export interface TurnFileChangeSummaryWire {
+    turnId: string;
+    sessionId: string;
+    projectId: string;
+    state: "running" | "completed" | "failed" | "cancelled";
+    startedAt: string;
+    completedAt?: string;
+    filesChanged: number;
+    files: TurnFileChangeRecord[];
+    truncated?: boolean;
+}
+export interface TurnFileChangesNotification {
+    sessionId: string;
+    turnId: string;
+    projectId: string;
+    state: "completed" | "failed" | "cancelled";
+    summary: TurnFileChangeSummaryWire;
+}
 /** Tool invocation started. */
 export interface TurnToolCallNotification {
     turnId: string;
@@ -948,6 +974,7 @@ export interface NotificationMethodMap {
     "turn.end": TurnEndNotification;
     "turn.error": TurnErrorNotification;
     "turn.recovery": TurnRecoveryNotification;
+    "turn.file_changes": TurnFileChangesNotification;
     "turn.tool_call": TurnToolCallNotification;
     "turn.tool_result": TurnToolResultNotification;
     "turn.tool_blocked": TurnToolBlockedNotification;

package/dist/types/runtime/execution/untrusted-tool-result.d.ts

@@ -0,0 +1,2 @@
+export declare function isUntrustedToolResult(toolName: string): boolean;
+export declare function wrapUntrustedToolResult<T>(toolName: string, payload: T): T;

package/dist/types/runtime/infra/feedback-distillation-worker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Feedback distillation worker (design §11; mini-design 2026-06-28 v2) — the idle-triggered sweep
+ * that turns a project's accumulated feedback into memory proposals. Scheduling mirrors the upload
+ * worker + dream: a pure work unit, callers serialize per project (§9.1 rule 9). It is append-only
+ * into the SHARED memory pipeline (proposeExtracted, source="feedback") — it never promotes; dream /
+ * consolidator own merge + promote (§11.2). The store-level idempotency key (§10) makes the sweep
+ * safe to re-run: a retried sweep, or a worker restart mid-sweep, never duplicates a proposal.
+ */
+import type { MemoryDreamProvider } from "../ports/memory-provider.js";
+export interface FeedbackDistillationResult {
+    candidates: number;
+    proposed: number;
+}
+/**
+ * One distillation sweep for a project: cluster active feedback into candidates, append each as a
+ * memory proposal. Fail-soft per candidate — one rejected proposal never aborts the rest of the
+ * sweep. Returns counts for logging. The memory provider must expose proposeExtracted (the dream
+ * provider does); if it doesn't, the sweep is a no-op.
+ */
+export declare function runFeedbackDistillationSweep(projectId: string, sink: Pick<MemoryDreamProvider, "proposeExtracted">, userId: string): Promise<FeedbackDistillationResult>;

package/dist/types/runtime/infra/feedback-distillation.d.ts

@@ -0,0 +1,30 @@
+import type { FeedbackEvent } from "./feedback-event-store.js";
+/** Minimum corroborating active events before a cluster becomes a proposal (mini-design §3.4). */
+export declare const MIN_EVIDENCE = 2;
+export interface FeedbackDistillationCandidate {
+    clusterKey: string;
+    /** Template preference sentence (dream LLM refines later — mini-design §9.3). */
+    text: string;
+    category: string;
+    importance: number;
+    confidence: number;
+    /** Audit trail + crash-safe idempotency, consumed by the extended proposeExtracted (§10). */
+    evidence: {
+        kind: "feedback";
+        refs: string[];
+        idempotencyKey: string;
+    };
+    /** Cluster diagnostics — not persisted as-is; surfaced for tests + logging. */
+    stats: {
+        evidence: number;
+        crossSession: boolean;
+        feedbackIds: string[];
+        turnIds: string[];
+    };
+}
+/**
+ * Cluster a project's feedback events into proposal candidates. Only active events count
+ * (retracted / replaced are filtered — §11.1). Clusters below MIN_EVIDENCE are dropped. Output is
+ * sorted by clusterKey for deterministic ordering across runs.
+ */
+export declare function distillFeedback(events: FeedbackEvent[]): FeedbackDistillationCandidate[];

package/dist/types/runtime/infra/feedback-event-store.d.ts

@@ -0,0 +1,160 @@
+export type FeedbackRating = "up" | "down";
+export type FeedbackState = "active" | "retracted" | "replaced";
+export type TelemetryStatus = "complete" | "partial" | "missing";
+export type FeedbackReason = "missed_requirement" | "incomplete" | "broken_file_link_or_panel" | "code_or_test_failed" | "factually_wrong" | "too_verbose" | "too_short" | "wrong_style" | "other";
+export interface FeedbackUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface FeedbackToolSummary {
+    calledTools: string[];
+    failedTools: string[];
+    blockedTools: string[];
+}
+export interface FeedbackFileContext {
+    changedFileCount?: number;
+    changedPathsPreview?: string[];
+    hasTurnFileChanges?: boolean;
+    diffOpenState?: "not_applicable" | "opened" | "failed" | "unknown";
+}
+export interface FeedbackBrowserContext {
+    url?: string;
+    hadToastError?: boolean;
+    visiblePanel?: "chat" | "artifact" | "diff" | "unknown";
+}
+export interface FeedbackEvent {
+    feedbackId: string;
+    rating: FeedbackRating;
+    reason?: FeedbackReason;
+    comment?: string;
+    state: FeedbackState;
+    projectId?: string;
+    sessionId: string;
+    turnId: string;
+    assistantMessageId: string;
+    userId?: string;
+    telemetryStatus: TelemetryStatus;
+    messageRole: "assistant";
+    messagePreview: string;
+    messageHash: string;
+    model?: string;
+    provider?: string;
+    agentMode?: "chat" | "solo" | "product" | "workflow" | "unknown";
+    sourceChannel?: string;
+    usage?: FeedbackUsage;
+    toolSummary?: FeedbackToolSummary;
+    fileContext?: FeedbackFileContext;
+    browserContext?: FeedbackBrowserContext;
+    upload?: {
+        eligible: boolean;
+        uploadedAt?: string;
+        uploadBatchId?: string;
+        redactionVersion?: string;
+    };
+    /**
+     * Local distillation bookkeeping (mini-design §6): records that this event was folded into a
+     * memory proposal, and under which cluster + idempotency key. Observability only — the crash-safe
+     * dedup guard is the store-level idempotency key on the proposal, not this field.
+     */
+    distill?: {
+        proposedAt: string;
+        clusterKey: string;
+        idempotencyKey: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/** Telemetry-joined + click-time context the handler assembles before persisting. */
+export interface FeedbackContext {
+    telemetryStatus: TelemetryStatus;
+    messagePreview: string;
+    messageHash: string;
+    userId?: string;
+    model?: string;
+    provider?: string;
+    agentMode?: FeedbackEvent["agentMode"];
+    sourceChannel?: string;
+    usage?: FeedbackUsage;
+    toolSummary?: FeedbackToolSummary;
+    fileContext?: FeedbackFileContext;
+    browserContext?: FeedbackBrowserContext;
+}
+export interface FeedbackSubmitInput {
+    rating: FeedbackRating;
+    reason?: FeedbackReason;
+    comment?: string;
+    projectId: string;
+    sessionId: string;
+    turnId: string;
+    assistantMessageId: string;
+    context: FeedbackContext;
+}
+export interface FeedbackStateEntry {
+    turnId: string;
+    assistantMessageId: string;
+    feedbackId: string;
+    rating: FeedbackRating;
+    reason?: FeedbackReason;
+    state: FeedbackState;
+    updatedAt: string;
+}
+export declare function hashMessageContent(content: string): string;
+/**
+ * Create / switch / re-activate the feedback for a turn. Returns the stable feedbackId and the
+ * resulting state. Submitting the SAME rating while already active is a no-op (idempotent retry).
+ */
+export declare function submitFeedback(input: FeedbackSubmitInput): Promise<{
+    feedbackId: string;
+    state: FeedbackState;
+}>;
+/**
+ * Retract the active feedback for a turn (the frontend calls this when the user re-clicks the
+ * already-selected button). Idempotent: retracting when there is nothing active is a no-op.
+ */
+export declare function retractFeedback(input: {
+    projectId: string;
+    turnId: string;
+    feedbackId?: string;
+}): Promise<{
+    ok: boolean;
+    feedbackId?: string;
+    state: FeedbackState | null;
+}>;
+/**
+ * Hydrate feedback state for a session's messages (initial render / refresh). Returns only ACTIVE
+ * feedback (absent = not rated) — the fixed contract per design §8.3, so the UI never has to
+ * interpret retracted/replaced records.
+ */
+export declare function getFeedbackState(input: {
+    projectId: string;
+    sessionId: string;
+    turnIds?: string[];
+    assistantMessageIds?: string[];
+}): Promise<{
+    states: FeedbackStateEntry[];
+}>;
+/**
+ * Events eligible for cloud upload that have not yet been assigned to a batch (design §10). The
+ * worker redacts + ships these; once assigned a batchId (delivered or queued for retry) they are
+ * skipped until a state change resets the upload marks.
+ */
+export declare function listUploadableFeedback(projectId: string): Promise<FeedbackEvent[]>;
+/** Mark an event as assigned to an in-flight upload batch (queued for retry, not yet delivered). */
+export declare function assignFeedbackBatch(projectId: string, turnId: string, uploadBatchId: string): Promise<void>;
+/** Mark an event as successfully uploaded (stamps uploadedAt + batch + redactionVersion). */
+export declare function markFeedbackUploaded(projectId: string, turnId: string, uploadBatchId: string, redactionVersion: string): Promise<void>;
+/**
+ * Active feedback eligible for memory distillation (mini-design §3.1). Distillation re-clusters the
+ * full active set every sweep; the store-level idempotency key (not a per-event flag) prevents
+ * duplicate proposals, so this intentionally returns ALL active events — already distilled or not.
+ * A newly added active event simply changes a cluster's id set and yields a fresh proposal.
+ */
+export declare function listDistillableFeedback(projectId: string): Promise<FeedbackEvent[]>;
+/** Stamp local distillation bookkeeping on an event (which cluster + idempotency key folded it in). */
+export declare function markFeedbackDistilled(projectId: string, turnId: string, info: {
+    clusterKey: string;
+    idempotencyKey: string;
+}): Promise<void>;
+/** Test helper: read the raw stored event for a turn (including retracted), or null. */
+export declare function __getFeedbackEventForTest(projectId: string, turnId: string): Promise<FeedbackEvent | null>;

package/dist/types/runtime/infra/feedback-outbox.d.ts

@@ -0,0 +1,26 @@
+export type OutboxOp = "uploadBatch";
+export interface OutboxEntry {
+    entryId: string;
+    /** Dedup key — re-enqueuing the same logical op is a no-op (no double upload). */
+    idempotencyKey: string;
+    op: OutboxOp;
+    payload: unknown;
+    attempts: number;
+    createdAt: string;
+    nextAttemptAt: string;
+    lastError?: string;
+}
+/** Enqueue a failed op for retry. Idempotent: an existing entry with the same key is kept as-is. */
+export declare function enqueueOutbox(projectId: string, input: {
+    idempotencyKey: string;
+    op: OutboxOp;
+    payload: unknown;
+}, now?: Date): Promise<OutboxEntry>;
+/** Entries whose backoff window has elapsed and that have not exhausted their retry budget. */
+export declare function listDueOutbox(projectId: string, now?: Date): Promise<OutboxEntry[]>;
+/** Drop a successfully-delivered entry. */
+export declare function removeOutbox(projectId: string, entryId: string): Promise<void>;
+/** Record a failed attempt: bump attempts + schedule the next retry with exponential backoff. */
+export declare function markOutboxFailure(projectId: string, entryId: string, error: string, now?: Date): Promise<void>;
+/** Entries that have exhausted their retry budget — kept for local audit, never re-sent. */
+export declare function listExhaustedOutbox(projectId: string): Promise<OutboxEntry[]>;