qlogicagent 2.18.2 → 2.18.3

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.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.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", "session.recovery_pending", "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", "workflow.approvalTimedOut"];
+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.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", "session.recovery_pending", "memory.updated", "skills.updated", "turn.memory_recall", "turn.memory_written", "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", "workflow.approvalTimedOut"];
 /**
  * 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.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.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", "session.recovery_pending", "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", "workflow.approvalTimedOut", "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.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", "session.recovery_pending", "memory.updated", "skills.updated", "turn.memory_recall", "turn.memory_written", "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", "workflow.approvalTimedOut", "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/memory-provider-lifecycle.d.ts

@@ -58,6 +58,9 @@ export interface MemorySearchOptions {
     llmConfig?: MemoryLlmConfig;
     /** Categories to boost during reranking (e.g. ["lesson", "preference"]). */
     preferredCategories?: string[];
+    /** Drop hits whose tags contain ALL strings of any group (resident-layer exclusion:
+     * entries already injected verbatim via the global INDEX must not be recalled again). */
+    excludeTagGroups?: string[][];
 }
 export interface MemoryIngestOptions {
     llmConfig?: MemoryLlmConfig;

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

@@ -163,6 +163,22 @@ export interface TurnSuggestionsNotification {
         action?: string;
     }>;
 }
+/** Memory recall visibility (Part B): fired when turn-time recall injected memories,
+ * so the UI can render a "based on N memories" disclosure row (recall was invisible before). */
+export interface TurnMemoryRecallNotification {
+    sessionId: string;
+    turnId: string;
+    count: number;
+    /** Truncated texts of the memories actually injected (post-cap), for the expanded list. */
+    titles: string[];
+}
+/** Memory write visibility (Part B): fired on the synchronous agent-remember tool path.
+ * Dream/async consolidation deliberately does NOT emit this (it surfaces via next-turn recall). */
+export interface TurnMemoryWrittenNotification {
+    items: Array<{
+        title: string;
+    }>;
+}
 /** Sidechain started execution. */
 export interface TurnSidechainStartedNotification {
     turnId: string;
@@ -250,6 +266,15 @@ export interface TurnMediaPersistedNotification {
         bytes: number;
         mimeType: string;
     }>;
+    /**
+     * URLs that FAILED to persist locally this turn (result keeps the remote URL / dangling temp
+     * path, which may expire). Present only when at least one file failed — persistence stays
+     * fail-open, but the degradation is surfaced instead of silently swallowed.
+     */
+    failures?: Array<{
+        remoteUrl: string;
+        error?: string;
+    }>;
 }
 /** Task state change. */
 export interface TurnTaskUpdatedNotification {
@@ -1011,6 +1036,8 @@ export interface NotificationMethodMap {
     "turn.reasoning_delta": TurnReasoningDeltaNotification;
     "turn.plan_update": TurnPlanUpdateNotification;
     "turn.suggestions": TurnSuggestionsNotification;
+    "turn.memory_recall": TurnMemoryRecallNotification;
+    "turn.memory_written": TurnMemoryWrittenNotification;
     "turn.sidechain_started": TurnSidechainStartedNotification;
     "turn.subagent_delta": TurnSubagentDeltaNotification;
     "turn.sidechain_completed": TurnSidechainCompletedNotification;

package/dist/types/runtime/config/tunable-defaults.d.ts

@@ -143,6 +143,12 @@ export declare const TASK_PANEL_GRACE_MS = 30000;
 export declare const MEMORY_PREFETCH_MAX_SESSION_BYTES: number;
 /** Max results per memory recall query. */
 export declare const MEMORY_PREFETCH_LIMIT_PER_RECALL = 10;
+/** Min hybrid score for recall injection. The old 0.1 default was a no-op filter —
+ * top-10 got injected wholesale and weak matches crowded the per-turn byte budget. */
+export declare const MEMORY_RECALL_MIN_SCORE = 0.35;
+/** Adaptive cliff cutoff: stop taking results when the next score drops by more than
+ * this ratio vs the previous one (2 relevant hits -> inject 2, don't pad to 10). */
+export declare const MEMORY_RECALL_CLIFF_RATIO = 0.4;
 /** LRU dedup set size for surfaced memory entries. */
 export declare const MEMORY_MAX_SURFACED_ENTRIES = 100;
 /** Min hours between dream consolidation runs. */

package/dist/types/runtime/execution/memory-decay.d.ts

@@ -49,8 +49,12 @@ export interface DecayCycleDeps {
     };
 }
 export interface DecayCycleResult {
-    /** Whether decay actually ran (false = skipped by gate). */
+    /** Whether decay actually ran (false = skipped by gate OR failed — see `failed`). */
     ran: boolean;
+    /** True when the cycle was ATTEMPTED and errored — distinguishes a failure from a cooldown skip. */
+    failed?: boolean;
+    /** Failure reason, present when failed=true. */
+    error?: string;
     /** Number of memories whose importance was reduced. */
     decayed: number;
     /** Number of memories archived (below threshold). */

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -8,6 +8,11 @@ export declare function estimateTokens(msg: CompressibleMessage): number;
 export declare function estimateTotalTokens(messages: CompressibleMessage[]): number;
 export declare function getCompressionMetrics(): import("../context/context-compression-strategies.js").CompressionMetricsSnapshot;
 export declare function getContextEngineRegistry(): ContextEngineRegistry;
+/**
+ * Prefixed onto the sync fallback when the LLM summarize call failed — the model
+ * (and anyone reading the compressed history) must know this stretch is low-fidelity.
+ */
+export declare const DEGRADED_SUMMARY_MARKER = "[summary degraded: LLM summarization failed]";
 /**
  * Create a summarization callback using an injected LLM transport.
  * For CLI mode: uses the same transport that powers the agent loop.

package/dist/types/runtime/hooks/memory-hooks.d.ts

@@ -25,6 +25,16 @@ export interface MemoryHooksDeps {
     getLastAssistantMessage?: () => string | undefined;
     /** Background LLM for implicit extraction. If provided, enables Layer 2. */
     llmExtract?: (prompt: string) => Promise<string | null>;
+    /** Part B write visibility: forwards turn.memory_written on auto-extract commits. */
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+    /** V3.2 usage 仪表:procedure 复用的 session 维度与负反馈计数落盘目录。 */
+    profileMemoryDir?: () => string;
+    /** V3.2: tag marking a distilled procedure memory (recall filter). cli injects so runtime never imports skills. */
+    procedureTag?: string;
+    /** V3.2: record distilled procedures recalled this turn (positive reuse signal). cli-injected. */
+    recordProcedureRecalls?: (procedureIds: string[], sessionId: string) => void;
+    /** V3.2: record negative feedback against distilled procedures (failed turn). cli-injected. */
+    recordProcedureNegatives?: (procedureIds: string[]) => void;
 }
 /** Session-scoped state for dedup and byte budget (CC parity). */
 export interface MemoryPrefetchState {

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -155,6 +155,9 @@ export declare function assembleBackendDescriptor(backend: AcpBackendConfig, cli
 export declare function assembleCustomAgentDescriptor(custom: CustomAgentDef, cliPath: string | null, hasConfig: boolean): AgentDescriptor;
 export declare class AcpDetector {
     private cache;
+    /** Last scan that COMPLETED, surviving clearCache() and failed rescans. list() prefers this
+     *  over an empty [] so a transient probe failure never reads as "no agents installed". */
+    private lastGoodScan;
     private configStore;
     private keySources;
     /** Shared in-flight async scan so concurrent scanAsync() callers (startup warm + a racing RPC)
@@ -188,6 +191,11 @@ export declare class AcpDetector {
      * Return cached results without IO. 冷缓存时后台预热（scanAsync）并返回 []，
      * 绝不在 RPC 路径上同步 scan —— 同步探测（11-18s+）会饿死单线程引擎循环
      * （x/product.confirm 60s 超时的根因）。调用方按"稍后再查"处理空列表。
+     *
+     * A background-scan failure is reported (console.error), never swallowed: a swallowed
+     * failure made list() return [] forever and downstream (product planning) treated
+     * "scan failed" as "no agents installed". When the fresh cache is gone but an older
+     * scan succeeded, that stale-but-real result is returned instead of [].
      */
     list(): AgentDescriptor[];
     /** Clear the detection cache. */

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -114,6 +114,8 @@ export declare class AcpProtocolAdapter {
     private child;
     private onNotification;
     private hostHandler;
+    /** Sessions whose session/set_model FAILED — running on the agent's default model, not the managed one. */
+    private modelMismatches;
     /**
      * Attach to a child process's stdio for ACP communication.
      * Constructs the official ClientSideConnection over the child's stdin/stdout. The connection's
@@ -172,6 +174,14 @@ export declare class AcpProtocolAdapter {
      * error is the backstop). Uses the generic sendRequest because the SDK has no typed set_model yet.
      */
     private selectSessionModel;
+    /**
+     * The recorded session/set_model failure for a session, if any — the session is alive but on
+     * the agent's DEFAULT model instead of the managed/platform one (wrong vendor/billing/capability).
+     */
+    getModelMismatch(sessionId: string): {
+        desired: string;
+        error: string;
+    } | undefined;
     /**
      * Send a prompt to a running ACP session (session/prompt). Content streams back via session/update
      * notifications during execution; the response carries only { stopReason, usage? }. On timeout the

package/dist/types/runtime/infra/agent-process.d.ts

@@ -291,6 +291,12 @@ export declare class AgentProcessManager {
      * Uses the ACP protocol adapter for lifecycle management.
      */
     private spawnAcpAgent;
+    /**
+     * Surface a recorded session/set_model failure: the session is alive but runs the agent's
+     * DEFAULT model instead of the managed/platform one (wrong vendor/billing/capability). Same
+     * agents.error channel as the other spawn/restart failures.
+     */
+    private reportModelMismatch;
     private syncNativeMcpConfig;
     /** Kill a specific child agent process. */
     kill(memberId: string): void;

package/dist/types/runtime/infra/astraclaw-capabilities.d.ts

@@ -8,6 +8,15 @@ export interface AstraClawCapabilityToolInput {
     availableToolNames?: Iterable<string>;
     currentEnvironment?: string;
     toolCatalog?: ToolCatalog;
+    /**
+     * Configured MCP servers serving NO tools this session (invalid config / connect failure).
+     * Disclosed in mcp_connectors_list so a failed server is visibly missing, not silently absent.
+     */
+    mcpServerFailures?: Array<{
+        name: string;
+        phase?: string;
+        error: string;
+    }>;
 }
 export type AstraClawCapabilityToolResult = {
     handled: false;

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

@@ -17,19 +17,13 @@ export declare function getWorkingMaterials(projectId: string, sessionId: string
     items: WorkingMaterialItem[];
     missing: WorkingMaterialItem[];
 }>;
-export declare function replaceWorkingMaterials(projectId: string, sessionId: string, items: unknown[]): Promise<{
+export interface WorkingMaterialsWriteResult {
     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[];
-}>;
+    /** 超过上限被淘汰的项;非空时调用方/UI 必须告知用户(绝不静默丢用户 pin 的数据)。 */
+    dropped?: WorkingMaterialItem[];
+}
+export declare function replaceWorkingMaterials(projectId: string, sessionId: string, items: unknown[]): Promise<WorkingMaterialsWriteResult>;
+export declare function upsertWorkingMaterial(projectId: string, sessionId: string, item: unknown): Promise<WorkingMaterialsWriteResult>;
+export declare function removeWorkingMaterial(projectId: string, sessionId: string, id: string): Promise<WorkingMaterialsWriteResult>;
+export declare function reorderWorkingMaterials(projectId: string, sessionId: string, ids: string[]): Promise<WorkingMaterialsWriteResult>;

package/dist/types/runtime/pet/pet-profile-service.d.ts

@@ -81,6 +81,13 @@ export declare class PetProfileService {
     private readonly profilePath;
     constructor(ownerUserId: string);
     loadProfile(): PetProfile;
+    /**
+     * Load the profile for a read-modify-write cycle. A corrupt profile file must
+     * never be replaced by a rebuilt default — throw so the caller fails loudly
+     * instead of silently destroying the user's pet data.
+     */
+    private loadProfileForWrite;
+    private readProfileState;
     updateSoul(soul: PetSoul | null): PetProfile;
     updatePreferences(update: Partial<PetPreferences>): PetProfile;
     saveJourneySnapshot(snapshot: JourneySnapshot): PetProfile;

package/dist/types/runtime/pet/petdex-forge-service.d.ts

@@ -9,7 +9,9 @@ export interface PetdexForgePackageOutput extends PetdexForgeOutput {
     validationPath: string;
     productionRunPath: string;
 }
-export declare function forgePetdexAsset(input: PetdexForgeRequest, generateImage: GeneratePetdexImage, options?: PetdexProductionOptions): Promise<PetdexForgeOutput>;
+export declare function forgePetdexAsset(input: PetdexForgeRequest, generateImage: GeneratePetdexImage, options?: PetdexProductionOptions): Promise<PetdexForgeOutput & {
+    qaSkippedJobs?: string[];
+}>;
 export declare function forgePetdexAssetPackage(params: {
     input: PetdexForgeRequest;
     outputDir: string;

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

@@ -4,6 +4,8 @@ export interface MemorySearchOptions {
     minScore?: number;
     preferredCategories?: string[];
     llmConfig?: unknown;
+    /** Drop hits whose tags contain ALL strings of any group (resident-layer exclusion). */
+    excludeTagGroups?: string[][];
 }
 export interface MemorySearchResult {
     blockId: string;

package/dist/types/runtime/ports/project-memory-store.d.ts

@@ -41,4 +41,6 @@ export interface ProjectMemoryStore {
 export interface ProjectMemoryStoreFactory {
     getRootPath(projectRoot: string): string;
     create(projectRoot: string): ProjectMemoryStore;
+    /** Read the user-level global memory INDEX for prompt injection (null when absent/empty). */
+    readUserIndexForPrompt(): string | null;
 }

package/dist/types/runtime/prompt/environment-context.d.ts

@@ -55,12 +55,24 @@ export declare function shellGuidanceLines(shellInfo: ShellInfo | undefined, she
  */
 export declare function createEnvironmentContextSection(cwdOverride?: string, shellInfo?: ShellInfo): SystemPromptSection;
 /**
- * Create the task guidance system prompt section.
- * Domain-aware: selects appropriate guidance based on detected or overridden task domain.
+ * Domain-specific guidance ONLY — the small, genuinely per-turn-variable block.
+ * Excludes universalGuidance() (which is domain-INVARIANT and lives in its own
+ * stable section, see createUniversalGuidanceSection). This is the single source
+ * of truth for domain content, so the combined section and the split sections
+ * never drift.
  *
  * @param domain - Task domain from auto-detection or host override.
  */
-export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPromptSection;
+export declare function renderDomainGuidanceBlock(domain?: TaskDomain): string[];
+/**
+ * Universal (domain-INVARIANT) working-approach guidance as a STABLE (memoized)
+ * system section. Byte-identical every turn regardless of the detected domain, so
+ * it belongs in the cacheable system-prompt prefix. The per-turn domain block
+ * (renderDomainGuidanceBlock) is deliberately NOT part of this section — it is
+ * injected as a system message right before the last user message so the system
+ * prompt stays byte-stable when the detected domain switches.
+ */
+export declare function createUniversalGuidanceSection(): SystemPromptSection;
 /**
  * Create a system prompt section that provides tool usage guidance.
  * CC parity: matches claude-code's getUsingYourToolsSection().

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

@@ -33,4 +33,11 @@ export declare function isExplicitNoToolTurn(messages: readonly PromptMessageLik
  * stay subject to the normal evidence filter.)
  */
 export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
+/**
+ * Prompt notice for an explicit "don't use tools" instruction. This INFORMS the
+ * model and leaves the judgment to it — the engine no longer strips the tool list
+ * (toolChoice="none"), which also silently disabled the reactive guards and
+ * misfired on quoted/reported speech ("he said don't use tools").
+ */
+export declare function createExplicitNoToolNoticeSection(): SystemPromptSection;
 export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;

package/dist/types/runtime/prompt/instruction-loader.d.ts

@@ -54,7 +54,6 @@ export declare function loadInstructions(cwd: string, hooks?: HookRegistry): Pro
  */
 export declare function buildInstructionsPrompt(files: InstructionFileInfo[]): string;
 export declare function extractLiteralResponseRequirements(files: InstructionFileInfo[]): LiteralResponseRequirement[];
-export declare function applyLiteralResponseRequirements(content: string, requirements: readonly LiteralResponseRequirement[]): string;
 /**
  * Get conditional rules that match a target file path.
  * CC parity: getManagedAndUserConditionalRules() + getMemoryFilesForNestedDirectory()

package/dist/types/runtime/session/inbound-upload-persistence.d.ts

@@ -34,6 +34,10 @@ export declare function persistInboundUploadUrl(url: string, projectId: string,
 /**
  * Persist + rewrite the inbound uploads on the LAST user message of a turn (the new message;
  * resumed history already carries persisted local URLs). Mutates and returns the message array.
+ *
+ * Failure parity with the document path (appendLocalDocumentNotesToText): when a media upload
+ * could NOT be persisted, the message gets a model-visible note instead of silently keeping a
+ * transport URL that expires with the turn — the model must know the reference is short-lived.
  */
 export declare function persistInboundUploadsForTurn(messages: ChatMessage[], projectId: string | undefined, sessionId: string | undefined): Promise<ChatMessage[]>;
 /**

package/dist/types/runtime/session/session-catalog.d.ts

@@ -1,4 +1,12 @@
 import type { SessionListEntry } from "./session-types.js";
 export declare function listSessions(limit: number | undefined, projectRoot: string): Promise<SessionListEntry[]>;
 export declare function deleteSession(sessionId: string, projectRoot: string): Promise<void>;
+/**
+ * ⚠️ Destructive cascade with NO user-visible confirmation: every pruned session goes through
+ * deleteSession, which permanently removes its transcript + metadata + checkpoints + uploads.
+ * Currently has NO caller. If you wire this up, the deletions must be surfaced to the user
+ * (count + which sessions) — silently reaping MAX_SESSIONS-overflow would be exactly the kind of
+ * invisible data loss docs/judgment-over-mechanism.md forbids. Also note listSessions skips
+ * unreadable-metadata sessions, so a prune pass under fs errors could mis-rank what "oldest" is.
+ */
 export declare function pruneOldSessions(projectRoot: string): Promise<number>;

package/dist/types/runtime/session/session-resume.d.ts

@@ -1,4 +1,9 @@
 import type { PersistedSession } from "./session-types.js";
+/** Coded error: the session's project root cannot be read at all (deleted dir, unplugged drive,
+ *  permissions). Distinguishable from the `null` return, which strictly means "this session has no
+ *  persisted transcript" — conflating the two made every caller silently start a NEW empty session
+ *  on a read failure (docs/judgment-over-mechanism.md: "read failed" ≠ "does not exist"). */
+export declare const PROJECT_ROOT_UNAVAILABLE = "PROJECT_ROOT_UNAVAILABLE";
 export declare function loadSessionForResume(sessionId: string, projectRoot: string, options?: {
     includeDisplayMetadata?: boolean;
 }): Promise<PersistedSession | null>;

package/dist/types/runtime/session/session-transcript-store.d.ts

@@ -6,10 +6,17 @@ export interface TranscriptLoadResult {
     /** 1-based line numbers that failed to parse (bounded to the first MAX_REPORTED_CORRUPT_LINES). */
     corruptLineNumbers: number[];
 }
+/**
+ * Outcome of an appendMessage call. "skipped-deleted" (the session was deleted — a LEGAL late-write
+ * no-op) is deliberately distinguishable from "failed" (the write itself failed — the message is
+ * LOST and callers must leave a trace / surface it), per docs/judgment-over-mechanism.md:
+ * "does not exist" and "write failed" must never be conflated into one silent boolean.
+ */
+export type AppendMessageOutcome = "appended" | "skipped-deleted" | "failed";
 export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot: string, turnId?: string, metadata?: {
     usage?: TokenUsage;
     displayMetadata?: MessageDisplayMetadata;
-}): Promise<boolean>;
+}): Promise<AppendMessageOutcome>;
 export declare function countTranscriptMessages(sessionId: string, projectRoot: string): Promise<number | null>;
 export declare function loadTranscript(sessionId: string, projectRoot: string, options?: {
     includeDisplayMetadata?: boolean;

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

@@ -1,4 +1,4 @@
-import type { PortableTool } from "../portable-tool.js";
+import type { PortableTool, PortableToolResult } from "../portable-tool.js";
 interface ToolRegistryLike {
     addTools(tools: PortableTool[]): void;
     getToolNames(): string[];
@@ -35,6 +35,17 @@ export interface McpSecurityIssue {
     code: "dangerous_egress" | "persistence" | "ioc_public_key";
     message: string;
 }
+/**
+ * A configured server that is NOT serving tools this session. Surfaced (not just logged)
+ * so capability queries (e.g. mcp_connectors_list) can disclose "configured but unavailable"
+ * instead of the server silently vanishing from the tool pool.
+ */
+export interface McpServerFailure {
+    name: string;
+    /** "config" = entry invalid, skipped before connect; "connect" = every connect attempt failed. */
+    phase: "config" | "connect";
+    error: string;
+}
 export interface McpManagerConfig {
     servers: McpServerEntry[];
     log?: {
@@ -67,7 +78,10 @@ export declare class McpManager {
     private toolCatalog?;
     private serverToolFilters;
     private serverOAuth;
+    private failedServers;
     constructor(config: McpManagerConfig);
+    /** Record (and loudly report) a server that will serve NO tools this session. */
+    private markServerFailed;
     private toServerDefinition;
     /**
      * Connect to all configured MCP servers and snapshot their tools.
@@ -81,6 +95,8 @@ export declare class McpManager {
     refreshServerTools(serverName: string): Promise<number>;
     /** Get names of all connected servers. */
     getConnectedServers(): string[];
+    /** Configured servers serving NO tools this session (invalid config or terminal connect failure). */
+    getFailedServers(): McpServerFailure[];
     /** Get total number of MCP tools across all servers. */
     getToolCount(): number;
     /**
@@ -95,6 +111,14 @@ export declare class McpManager {
     private registerTools;
     private removeRegisteredTool;
 }
+/**
+ * Flatten an MCP CallToolResult into a text-bearing PortableToolResult.
+ * Non-text blocks (image/audio/resource…) cannot be dropped silently: content is
+ * the only channel the model sees, so the omission is disclosed in the text —
+ * "(no text output)" for a result that DID produce blocks is a lie.
+ * Exported for unit tests only.
+ */
+export declare function toPortableResult(result: unknown): PortableToolResult;
 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 {

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

@@ -32,6 +32,8 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     private attachmentStore;
     private userIdPrefix;
     private dbPath;
+    /** One-shot flag: the embedding-degradation trace is logged once per provider instance. */
+    private embeddingFailureLogged;
     constructor(config: LocalMemoryProviderConfig);
     /** Persist an uploaded attachment (orphan until linked at commit). */
     adoptAttachment(input: {
@@ -57,9 +59,18 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     /** Persist the understood/extracted text on an attachment row. */
     setAttachmentText(id: string, text: string): void;
     private resolveUserId;
+    /**
+     * The embedding API failing silently downgrades every search to FTS-only —
+     * leave one error-level trace per provider instance (deduped so a broken
+     * endpoint does not flood the log on every query).
+     */
+    private noteEmbeddingFailure;
     private buildEmbedding;
     search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
     ingest(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
+    /** Public embedding access for task-distillation signatures (R3). Null when
+     * the embedding provider is unavailable — callers must degrade, not throw. */
+    embedText(text: string): Promise<Float32Array | null>;
     addText(text: string, userId: string, options?: MemoryIngestOptions & {
         category?: string;
         importance?: number;
@@ -102,6 +113,9 @@ export declare class LocalMemoryProvider implements MemoryProvider {
      * Apply feedback to a memory (useful/irrelevant/outdated/wrong).
      * Adjusts importance or archives/deletes based on signal.
      */
+    /** V3 promote/demote: archive(技能接棒,记忆退役)与 unarchive(降格回归)成对。
+     * claims 状态随动,防 archived 记忆的 claim 继续参与冲突/召回。 */
+    setMemoryArchived(memoryId: string, archived: boolean): boolean;
     feedback(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
         affected: number;
     }>;

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

@@ -103,6 +103,8 @@ export declare class LocalMemoryStore {
      * Used by dedup gate when a similar but newer memory supersedes an older one.
      */
     archive(id: string): boolean;
+    /** V3 demote(降格)恢复:archived procedure 回归召回池,与 archive 成对。 */
+    unarchive(id: string): boolean;
     /**
      * Temporal expiry: archive event/plan memories whose event_date has passed
      * beyond a grace period (e.g., "meeting tomorrow" 3 days after it happened).

package/dist/types/skills/memory/memdir.d.ts

@@ -8,6 +8,14 @@ export declare const TOPIC_FILE_MAX_CHARS = 8192;
 export declare function getMemdirPath(projectRoot: string): string;
 /** Full path to INDEX.md */
 export declare function getIndexPath(projectRoot: string): string;
+/** Global-layer size budget: a cheat-sheet, not a memory store. */
+export declare const USER_INDEX_MAX_CHARS = 2048;
+export declare const USER_INDEX_MAX_LINES = 40;
+/** Full path to the user-level global INDEX.md (QLOGICAGENT_HOME aware). */
+export declare function getUserIndexPath(): string;
+/** Read the global layer for prompt injection, capped by the cheat-sheet budget.
+ * Returns null when absent/empty — the section simply doesn't render. */
+export declare function readUserIndexForPrompt(): string | null;
 export interface MemdirFileInfo {
     name: string;
     /** Size in bytes */