qlogicagent 2.16.5 → 2.16.7

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/skill-resolver.d.ts

@@ -26,8 +26,14 @@ export interface ResolvedSkill {
     systemGenerated: boolean;
     description?: string;
     version?: string;
+    requiredTools?: string[];
+    environments?: string[];
 }
 export declare function isSystemGeneratedSkillName(name: string): boolean;
+export interface SkillActivationContext {
+    availableToolNames?: Iterable<string>;
+    currentEnvironment?: string;
+}
 /**
  * Resolve all skills in the global store, annotated with global/project mute state and whether
  * they're active in the given project context.
@@ -35,9 +41,9 @@ export declare function isSystemGeneratedSkillName(name: string): boolean;
  * Returns ALL store skills (active and inactive) so listing surfaces can show enable/disable state;
  * callers that only want active skills filter `.active` (or use resolveActiveSkills).
  */
-export declare function resolveSkills(projectRoot?: string): ResolvedSkill[];
+export declare function resolveSkills(projectRoot?: string, activation?: SkillActivationContext): ResolvedSkill[];
 /** Only the skills active in the given project (for the system-prompt skills catalog / resolution). */
-export declare function resolveActiveSkills(projectRoot?: string): ResolvedSkill[];
+export declare function resolveActiveSkills(projectRoot?: string, activation?: SkillActivationContext): ResolvedSkill[];
 /**
  * Resolve a single skill by name to its store paths, or null if not present.
  * Resolution honors only the global store (single source of truth) and ignores

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

@@ -21,10 +21,19 @@ export interface McpServerEntry {
     url?: string;
     /** Extra HTTP headers (http only) */
     headers?: Record<string, string>;
-    /** Init timeout (ms) — accepted for config compatibility; mcporter owns connect timeouts. */
-    initTimeoutMs?: number;
     /** Whether this server is disabled (skip connection) */
     disabled?: boolean;
+    /** Allow the MCP runtime to start an OAuth flow for this server; default is cached-token/headless only. */
+    oauth?: boolean;
+    /** Optional tool-name allow/deny filters applied after connect-time discovery. */
+    tools?: {
+        include?: string[];
+        exclude?: string[];
+    };
+}
+export interface McpSecurityIssue {
+    code: "dangerous_egress" | "persistence" | "ioc_public_key";
+    message: string;
 }
 export interface McpManagerConfig {
     servers: McpServerEntry[];
@@ -37,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;
@@ -45,6 +65,8 @@ export declare class McpManager {
     private log;
     private workspaceRoot?;
     private toolCatalog?;
+    private serverToolFilters;
+    private serverOAuth;
     constructor(config: McpManagerConfig);
     private toServerDefinition;
     /**
@@ -56,6 +78,7 @@ export declare class McpManager {
      * Register all snapshotted MCP tools into the tool pool.
      */
     injectTools(): void;
+    refreshServerTools(serverName: string): Promise<number>;
     /** Get names of all connected servers. */
     getConnectedServers(): string[];
     /** Get total number of MCP tools across all servers. */
@@ -67,9 +90,15 @@ export declare class McpManager {
     disconnectAll(): Promise<void>;
     private toPortableTool;
     private wrapToolsForWorkspaceBoundary;
+    private injectPortableTools;
+    private retractServerTools;
     private registerTools;
     private removeRegisteredTool;
 }
 export declare function validateMcpToolWorkspaceBoundary(toolName: string, args: unknown, workspaceRoot: string | undefined): string | null;
 export declare function parseMcpConfig(json: unknown): McpServerEntry[];
+export declare function filterMcpTools<T extends {
+    name: string;
+}>(tools: readonly T[], filter?: McpServerEntry["tools"]): T[];
+export declare function validateMcpServerSecurity(entry: McpServerEntry): McpSecurityIssue[];
 export {};

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

package/dist/types/skills/memory/local-store-records.d.ts

@@ -1,3 +1,12 @@
+/** Lightweight attachment reference carried on records / atlas wire (no bytes, no extractedText). */
+export interface MemoryAttachmentRef {
+    id: string;
+    kind: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    url: string;
+}
 export interface MemoryRecord {
     id: string;
     text: string;
@@ -15,6 +24,8 @@ export interface MemoryRecord {
     accessCount: number;
     lastAccessedAt: number;
     isArchived: boolean;
+    /** Lightweight attachment refs (populated by the provider for atlas/detail). */
+    attachments?: MemoryAttachmentRef[];
 }
 export interface MemoryInsertInput {
     text: string;
@@ -84,7 +95,7 @@ export interface MemoryAtlasResult {
         endAt: number;
     } | null;
 }
-export type MemorySourceKind = "manual" | "explicit" | "document" | "image" | "video" | "auto" | "turn" | "dream" | "agent";
+export type MemorySourceKind = "manual" | "explicit" | "document" | "image" | "video" | "auto" | "turn" | "dream" | "agent" | "feedback";
 export type MemoryClaimStatus = "active" | "superseded" | "conflicted" | "archived" | "pending_confirmation";
 export type MemoryProposalStatus = "pending" | "accepted" | "merged" | "conflicted" | "rejected";
 export interface MemoryObservationInput {
@@ -119,6 +130,12 @@ export interface MemoryProposalInput {
     tags?: string[];
     status?: MemoryProposalStatus;
     relatedClaimIds?: string[];
+    /**
+     * Crash-safe dedup key for evidence-bearing sources (feedback distillation — §10). When set,
+     * proposeExtracted skips inserting a duplicate proposal for the same key. Left undefined by all
+     * existing callers (LLM extraction / dream / manual), so their behaviour is unchanged.
+     */
+    idempotencyKey?: string;
 }
 export interface MemoryProposalRecord extends Omit<MemoryProposalInput, "value" | "validTime" | "tags" | "status" | "relatedClaimIds"> {
     id: string;