qlogicagent 2.16.6 → 2.16.7

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[]>;

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

@@ -0,0 +1,71 @@
+import type { FeedbackEvent, FeedbackRating, FeedbackReason, FeedbackState, FeedbackToolSummary, FeedbackUsage, TelemetryStatus } from "./feedback-event-store.js";
+/** Bump when the redaction rules change so uploaded samples stay traceable (§8.6/§13). */
+export declare const REDACTION_VERSION = "feedback-redaction-v1";
+export interface RedactedFeedbackEvent {
+    feedbackId: string;
+    rating: FeedbackRating;
+    reason?: FeedbackReason;
+    state: FeedbackState;
+    /** Hashed identity — correlate without exposing local ids (§8.6). */
+    messageHash: string;
+    sessionIdHash: string;
+    projectIdHash?: string;
+    turnIdHash: string;
+    /** ≤500 chars, secrets/emails/absolute-paths scrubbed (§13). */
+    messagePreview: string;
+    model?: string;
+    provider?: string;
+    agentMode?: FeedbackEvent["agentMode"];
+    sourceChannel?: string;
+    usage?: FeedbackUsage;
+    /** Tool names only (never args). */
+    toolSummary?: FeedbackToolSummary;
+    fileContext?: {
+        changedFileCount?: number;
+        hasTurnFileChanges?: boolean;
+        diffOpenState?: "not_applicable" | "opened" | "failed" | "unknown";
+    };
+    browserContext?: {
+        hadToastError?: boolean;
+        visiblePanel?: "chat" | "artifact" | "diff" | "unknown";
+    };
+    telemetryStatus: TelemetryStatus;
+    redactionVersion: string;
+    createdAt: string;
+}
+export interface FeedbackRollup {
+    rollupId: string;
+    periodStart: string;
+    periodEnd: string;
+    total: number;
+    upCount: number;
+    downCount: number;
+    /** Down-vote reason → count. */
+    byReason: Record<string, number>;
+    byModel: Record<string, {
+        up: number;
+        down: number;
+    }>;
+    byAgentMode: Record<string, {
+        up: number;
+        down: number;
+    }>;
+    telemetryStatusCounts: {
+        complete: number;
+        partial: number;
+        missing: number;
+    };
+    redactionVersion: string;
+    createdAt: string;
+}
+/** Truncate to the preview limit and scrub api keys / emails / absolute paths (§13). */
+export declare function sanitizePreview(text: string): string;
+/** Map a local feedback event to its upload-safe redacted form (§8.6/§13). */
+export declare function redactFeedbackEvent(event: FeedbackEvent, redactionVersion?: string): RedactedFeedbackEvent;
+/** Pre-aggregate a batch of local events into a rollup for low-cost trend upload (§10). */
+export declare function aggregateFeedbackRollup(events: FeedbackEvent[], input: {
+    rollupId: string;
+    periodStart: string;
+    periodEnd: string;
+    redactionVersion?: string;
+}): FeedbackRollup;

package/dist/types/runtime/infra/feedback-upload-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Feedback upload client — the single HTTP exit that ships redacted feedback to the llmrouter
+ * feedback backend (design §8.6, §9.1 rule 4). The redaction worker calls this directly; the
+ * messageFeedback.uploadBatch RPC wraps it for manual/test triggers.
+ *
+ * Transport mirrors the usage client: append the route to the llmrouter base already injected into
+ * the agent (QLOGIC_LLMROUTER_BASE_URL, e.g. https://www.qlogicagent.com/api) and authenticate with
+ * the injected Bearer QLOGIC_LLMROUTER_ACCESS_TOKEN. Feedback lands at <base>/client/feedback, so a
+ * batch POSTs to <base>/client/feedback/uploadBatch — the contract the llmrouter ingest endpoint
+ * (Phase 3b) implements. No dedicated feedback env: one llmrouter base, like /client/usage.
+ */
+import type { FeedbackRollup, RedactedFeedbackEvent } from "./feedback-redaction.js";
+export interface UploadBatchInput {
+    batchId: string;
+    events: RedactedFeedbackEvent[];
+    rollups: FeedbackRollup[];
+    redactionVersion: string;
+    clientBuild?: string;
+    runtimeVersion?: string;
+    qlogicagentVersion?: string;
+}
+export interface UploadBatchResult {
+    ok: boolean;
+    accepted?: number;
+    status?: number;
+    error?: string;
+}
+/**
+ * Resolve the feedback ingest base, derived from the llmrouter base already injected into the agent
+ * (QLOGIC_LLMROUTER_BASE_URL), mirroring how the usage client reaches /client/usage. Returns
+ * undefined when llmrouter is not configured.
+ */
+export declare function resolveFeedbackUploadBaseUrl(): string | undefined;
+/**
+ * Ship one redacted batch to llmrouter. Fail-soft: an unconfigured base or a transport/HTTP error
+ * returns { ok: false }, so the caller (worker) keeps the events eligible and queues a retry rather
+ * than dropping feedback. Idempotent at the server by batchId + event id (§9.1 rule 5).
+ */
+export declare function uploadFeedbackBatch(input: UploadBatchInput, signal?: AbortSignal): Promise<UploadBatchResult>;

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

@@ -0,0 +1,11 @@
+export interface FeedbackSweepResult {
+    uploaded: number;
+    queued: number;
+    retried: number;
+}
+/**
+ * One feedback upload sweep for a project. Retries due outbox batches, then redacts + ships any
+ * newly uploadable events. Fail-soft: a failed upload is queued in the outbox (its events assigned
+ * the batchId so they are not re-picked) and retried on a later sweep with backoff.
+ */
+export declare function runFeedbackUploadSweep(projectId: string, now?: Date): Promise<FeedbackSweepResult>;

package/dist/types/runtime/infra/turn-baseline-store.d.ts

@@ -0,0 +1,102 @@
+export type TurnBaselineState = "running" | "completed" | "failed" | "cancelled";
+export type FileChangeStatus = "added" | "modified" | "deleted" | "renamed" | "moved" | "copied" | "unchanged";
+export type SnapshotKind = "missing" | "text" | "binary" | "directory" | "too-large";
+export interface FileSnapshot {
+    exists: boolean;
+    kind: SnapshotKind;
+    sizeBytes?: number;
+    sha256?: string;
+    inlineContent?: string;
+    contentRef?: string;
+}
+export interface TurnFileChange {
+    path: string;
+    previousPath?: string;
+    status: FileChangeStatus;
+    additions?: number;
+    deletions?: number;
+    before?: FileSnapshot;
+    after?: FileSnapshot;
+}
+export interface TurnChangeSummary {
+    turnId: string;
+    sessionId: string;
+    projectId: string;
+    state: TurnBaselineState;
+    startedAt: string;
+    completedAt?: string;
+    filesChanged: number;
+    files: TurnFileChange[];
+    truncated?: boolean;
+}
+export declare function resolveProjectRelativePath(projectRoot: string, input: string): string | null;
+export declare function startTurnBaseline(input: {
+    turnId: string;
+    sessionId: string;
+    projectId?: string;
+    workspaceDir?: string;
+    seedPaths?: unknown;
+}): Promise<void>;
+export declare function captureFileBefore(input: {
+    turnId?: string;
+    projectId?: string;
+    workspaceDir?: string;
+    path: string;
+    entryPath?: string;
+    previousPath?: string;
+}): Promise<void>;
+export declare function captureFileAfter(input: {
+    turnId?: string;
+    projectId?: string;
+    workspaceDir?: string;
+    path: string;
+    entryPath?: string;
+    previousPath?: string;
+    status?: FileChangeStatus;
+}): Promise<void>;
+export declare function captureAbsoluteBefore(input: {
+    turnId?: string;
+    workspaceDir: string;
+    absolutePath: string;
+}): Promise<void>;
+export declare function captureAbsoluteAfter(input: {
+    turnId?: string;
+    workspaceDir: string;
+    absolutePath: string;
+    status?: FileChangeStatus;
+}): Promise<void>;
+export declare function finalizeTurnBaseline(input: {
+    turnId: string;
+    state: TurnBaselineState;
+}): Promise<TurnChangeSummary | null>;
+export declare function getTurnBaselineSummary(projectId: string, turnId: string): Promise<TurnChangeSummary | null>;
+export declare function listRecentTurnBaselines(input: {
+    projectId: string;
+    sessionId?: string;
+    limit?: number;
+}): Promise<{
+    summaries: TurnChangeSummary[];
+}>;
+export declare function getTurnBaselineFileBaseline(input: {
+    projectId: string;
+    turnId: string;
+    path: string;
+}): Promise<{
+    path: string;
+    content: string | null;
+    snapshot: FileSnapshot | null;
+}>;
+export declare function getTurnBaselineFileDiff(input: {
+    projectId: string;
+    turnId: string;
+    path: string;
+}): Promise<{
+    path: string;
+    previousPath?: string;
+    status: FileChangeStatus;
+    original: string;
+    modified: string;
+    language?: string;
+    additions?: number;
+    deletions?: number;
+}>;

package/dist/types/runtime/infra/turn-telemetry-store.d.ts

@@ -0,0 +1,59 @@
+export type AgentMode = "chat" | "solo" | "product" | "workflow" | "unknown";
+export interface TurnTelemetryUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface TurnTelemetryToolSummary {
+    calledTools: string[];
+    failedTools: string[];
+    blockedTools: string[];
+}
+export interface TurnTelemetryFileContext {
+    changedFileCount?: number;
+    changedPathsPreview?: string[];
+    hasTurnFileChanges?: boolean;
+}
+export interface TurnTelemetrySnapshot {
+    turnId: string;
+    sessionId: string;
+    projectId?: string;
+    /** Gateway-stamped alias; v1 MUST equal turnId (design §7.3). Set at finalize. */
+    assistantMessageId?: string;
+    model?: string;
+    provider?: string;
+    agentMode?: AgentMode;
+    sourceChannel?: string;
+    usage?: TurnTelemetryUsage;
+    toolSummary?: TurnTelemetryToolSummary;
+    fileContext?: TurnTelemetryFileContext;
+    createdAt: string;
+    finalizedAt?: string;
+}
+/** Fields that can be merged into a turn's telemetry record as the turn progresses. */
+export type TurnTelemetryPatch = Partial<Omit<TurnTelemetrySnapshot, "turnId" | "createdAt" | "finalizedAt" | "assistantMessageId">>;
+/**
+ * Merge a telemetry fragment into the in-memory record for a turn. Pieces (tool summary,
+ * usage/model, file context) arrive at different points in the pipeline and upsert into the
+ * same turnId record. Safe to call before the projectId is known; the first call seeds it.
+ */
+export declare function recordTurnTelemetry(turnId: string, patch: TurnTelemetryPatch): void;
+/**
+ * Flush the accumulated telemetry for a turn to disk and drop it from memory. Returns null
+ * (after dropping the in-memory record) when no projectId resolved — telemetry, like the turn
+ * baseline, is only persisted for turns that belong to a registered project.
+ */
+export declare function finalizeTurnTelemetry(input: {
+    turnId: string;
+    projectId?: string;
+}): Promise<TurnTelemetrySnapshot | null>;
+export declare function getTurnTelemetryRecord(projectId: string, turnId: string): Promise<TurnTelemetrySnapshot | null>;
+export declare function listTurnTelemetryBySession(input: {
+    projectId: string;
+    sessionId?: string;
+    limit?: number;
+}): Promise<{
+    records: TurnTelemetrySnapshot[];
+}>;
+/** Test/maintenance helper: drop any in-memory telemetry not yet finalized. */
+export declare function __resetActiveTurnTelemetryForTest(): void;

package/dist/types/runtime/infra/working-materials-store.d.ts

@@ -0,0 +1,35 @@
+export type WorkingMaterialKind = "workspace" | "instructions" | "generated" | "url";
+export interface WorkingMaterialItem {
+    id: string;
+    projectId: string;
+    sessionId: string;
+    sourceKind: WorkingMaterialKind;
+    path?: string;
+    title: string;
+    viewerHint?: string;
+    pinned: boolean;
+    order: number;
+    addedAt: string;
+    updatedAt: string;
+    missing?: boolean;
+}
+export declare function getWorkingMaterials(projectId: string, sessionId: string): Promise<{
+    items: WorkingMaterialItem[];
+    missing: WorkingMaterialItem[];
+}>;
+export declare function replaceWorkingMaterials(projectId: string, sessionId: string, items: unknown[]): Promise<{
+    ok: true;
+    items: WorkingMaterialItem[];
+}>;
+export declare function upsertWorkingMaterial(projectId: string, sessionId: string, item: unknown): Promise<{
+    ok: true;
+    items: WorkingMaterialItem[];
+}>;
+export declare function removeWorkingMaterial(projectId: string, sessionId: string, id: string): Promise<{
+    ok: true;
+    items: WorkingMaterialItem[];
+}>;
+export declare function reorderWorkingMaterials(projectId: string, sessionId: string, ids: string[]): Promise<{
+    ok: true;
+    items: WorkingMaterialItem[];
+}>;

package/dist/types/runtime/ports/memory-provider.d.ts

@@ -35,6 +35,12 @@ export interface MemoryExtractionItem {
     tags?: string[];
     /** Ids of already-uploaded attachments to link to this memory on commit. */
     attachmentIds?: string[];
+    /** Evidence trail for distillation-style sources (feedback — §10): audit refs + crash-safe dedup key. */
+    evidence?: {
+        kind: string;
+        refs: string[];
+        idempotencyKey: string;
+    };
 }
 export interface MemoryConsolidationWriteResult {
     memoriesAdded?: number;

package/dist/types/runtime/ports/tool-contracts.d.ts

@@ -64,6 +64,7 @@ export interface ToolBootstrapConfig {
         debug(message: string): void;
     };
     getTaskScopeKey?(): string | undefined;
+    getCurrentTurnId?(): string | undefined;
     onExecProgress?(progress: ToolBootstrapProgress): void;
 }
 export interface ToolBootstrap {

package/dist/types/runtime/prompt/fresh-workspace-evidence.d.ts

@@ -21,5 +21,19 @@ export declare function getFreshWorkspaceEvidencePolicy(messages: readonly Promp
 export declare function looksLikeBuildIntent(messages: readonly PromptMessageLike[] | string): boolean;
 export declare function isLightweightChatTurn(messages: readonly PromptMessageLike[] | string): boolean;
 export declare function isExplicitNoToolTurn(messages: readonly PromptMessageLike[] | string): boolean;
+/**
+ * Orchestration / capability primitives that survive every evidence filter.
+ * The policy's job is to FORCE fresh-evidence tools into the turn, not to
+ * strip the coordination layer — removing task/agent here silently breaks
+ * sub-agent delegation and background-task tracking on any turn whose text
+ * happens to match an evidence pattern (e.g. "write reports/x.json").
+ * `skill_view` belongs here for the same reason: it is the capability-invocation
+ * primitive, and the `# Available Skills` section tells the model to call it.
+ * Stripping `skill_view` on a file/mutation/shell turn (i.e. almost every real task)
+ * makes that instruction impossible to follow — the model cannot call a tool it
+ * was never given — which was the entire "skills never self-activate" bug.
+ * (skills_list / skill_manage are not load-bearing for self-activation, so they
+ * stay subject to the normal evidence filter.)
+ */
 export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
 export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;

package/dist/types/skills/mcp/mcp-manager.d.ts

@@ -46,6 +46,17 @@ export interface McpManagerConfig {
     /** Runtime-owned catalog used for dynamic MCP tool injection. */
     toolCatalog?: ToolRegistryLike;
 }
+/**
+ * Run `attempt` up to `options.attempts` times, backing off `baseDelayMs * n`
+ * between tries. Returns the first success; rethrows the last error if every
+ * attempt fails. `sleep` is injectable so callers (and tests) control timing.
+ */
+export declare function connectWithRetry<T>(attempt: () => Promise<T>, options: {
+    attempts: number;
+    baseDelayMs: number;
+    sleep?: (ms: number) => Promise<void>;
+    onRetry?: (attemptNumber: number, err: unknown) => void;
+}): Promise<T>;
 export declare class McpManager {
     private runtime;
     private definitions;

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

@@ -162,7 +162,7 @@ export declare class LocalMemoryProvider implements MemoryProvider {
         page?: number;
         pageSize?: number;
         activeOnly?: boolean;
-    }): import("./local-store.js").MemoryRecord[];
+    }): import("./local-store-records.js").MemoryRecord[];
     /**
      * Find memories by event date (+/- tolerance). For temporal context retrieval.
      */
@@ -178,8 +178,8 @@ export declare class LocalMemoryProvider implements MemoryProvider {
         bucketCount?: number;
         clusterLimit?: number;
         activeOnly?: boolean;
-    }): import("./local-store.js").MemoryAtlasResult;
-    findByEventDate(userId: string, targetDate: string, toleranceDays?: number): import("./local-store.js").MemorySearchHit[];
+    }): import("./local-store-records.js").MemoryAtlasResult;
+    findByEventDate(userId: string, targetDate: string, toleranceDays?: number): import("./local-store-records.js").MemorySearchHit[];
     /**
      * Find related memories (event continuity detection).
      * Given a new memory, finds existing memories that are semantically related