@goondocks/myco 0.21.0 → 0.21.2

package/dist/{chunk-NGH7U6A3.js → chunk-HCT7RMM2.js}

@@ -8,21 +8,22 @@ import {
   buildRunAccountingUpdate,
   buildUsageData,
   checkpointResultsForResume,
-  errorMessage,
   inferRuntimeFromProviderType,
+  isExpiredSessionError,
   isSessionResumeFailure,
   parseCheckpointState,
   resolveProviderForResume,
   serializeCheckpointState,
   summarizePhaseCosts
-} from "./chunk-6LB7XELY.js";
+} from "./chunk-QATYARI5.js";
 import {
   fullTextSearch,
-  hydrateSearchResults
-} from "./chunk-LVIY7P35.js";
+  hydrateSearchResults,
+  sanitizeFtsQuery
+} from "./chunk-QLLBJEM7.js";
 import {
   loadAllTasks
-} from "./chunk-ILJPRYES.js";
+} from "./chunk-USVFEWYL.js";
 import {
   getAgent,
   getDefaultTask,
@@ -31,7 +32,10 @@ import {
   loadSystemPrompt,
   resolveDefinitionsDir,
   resolveEffectiveConfig
-} from "./chunk-JZS6GZ6T.js";
+} from "./chunk-AUIXX33A.js";
+import {
+  errorMessage
+} from "./chunk-LQIPXVDH.js";
 import {
   countToolCallsByRun,
   insertTurn,
@@ -59,12 +63,11 @@ import {
   getSpore,
   insertSpore,
   listDigestExtracts,
-  listSporeIdsSince,
   listSpores,
   updateSporeStatus,
   upsertCortexInstructions,
   upsertDigestExtract
-} from "./chunk-F3OEQYLS.js";
+} from "./chunk-DBBO6FHE.js";
 import {
   countSessions,
   getActiveSessionIds,
@@ -78,7 +81,7 @@ import {
   AGENT_SETTABLE_STATUSES,
   CANDIDATE_STATUS,
   createSchema
-} from "./chunk-RL5R4CQU.js";
+} from "./chunk-DTWUHHFI.js";
 import {
   loadMergedConfig
 } from "./chunk-53RPGOEN.js";
@@ -89,7 +92,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   getPluginVersion
-} from "./chunk-BUTL6IFS.js";
+} from "./chunk-Z55WGA2J.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -97,6 +100,7 @@ import {
   CONTENT_HASH_ALGORITHM,
   DEFAULT_AGENT_ID,
   DEFAULT_LIST_LIMIT,
+  DIGEST_TIERS,
   EDGE_TYPE_DERIVED_FROM,
   EDGE_TYPE_EXTRACTED_FROM,
   EDGE_TYPE_FROM_SESSION,
@@ -197,6 +201,7 @@ var STATUS_RUNNING = "running";
 var STATUS_COMPLETED = "completed";
 var STATUS_FAILED = "failed";
 var RESUME_STATUS_READY = "ready";
+var RESUME_STATUS_SESSION_EXPIRED = "session_expired";
 var RUN_COLUMNS = [
   "id",
   "agent_id",
@@ -1251,6 +1256,32 @@ function deleteSkillRecordCascade(idOrName) {
   return { id: record.id, name: record.name };
 }
 
+// src/agent/semantic-shortlist.ts
+async function shortlistSemanticIds(options) {
+  const {
+    provider,
+    namespace,
+    query: query2,
+    candidateIds,
+    maxResults,
+    overFetch,
+    threshold,
+    filters
+  } = options;
+  if (!provider || maxResults <= 0) return [];
+  const queryVector = await provider.embedQuery(query2);
+  if (!queryVector) return [];
+  const results = provider.searchVectors(queryVector, {
+    namespace,
+    limit: Math.max(maxResults, maxResults * overFetch),
+    threshold,
+    filters
+  });
+  const shortlisted = candidateIds ? results.filter((result) => candidateIds.has(result.id)) : results;
+  shortlisted.sort((a, b) => b.similarity - a.similarity);
+  return shortlisted.slice(0, maxResults).map((result) => result.id);
+}
+
 // src/agent/tools/skill-validator.ts
 var import_yaml = __toESM(require_dist(), 1);
 var MAX_SKILL_LINES = 800;
@@ -1706,7 +1737,57 @@ function buildSkillSurveyInstruction(agentId) {
   return { instruction: parts.join("\n") };
 }
 var SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS = 24;
-var SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN = 8;
+var SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN = 3;
+var SKILL_EVOLVE_RECENT_SPORE_SCAN_LIMIT = 40;
+var SKILL_EVOLVE_RELEVANT_SPORE_LIMIT = 10;
+var SKILL_EVOLVE_SEMANTIC_OVERFETCH = 4;
+var SKILL_EVOLVE_SEMANTIC_THRESHOLD = 0;
+function normalizeSkillName(name) {
+  return name.replace(/[-_:]+/g, " ");
+}
+function buildSporeSearchText(spore) {
+  return [spore.observation_type, spore.content, spore.context, spore.tags, spore.file_path].filter(Boolean).join(" ");
+}
+function selectRelevantSporeIdsByLexicalOverlap(skill, recentSpores) {
+  if (recentSpores.length === 0) return [];
+  const skillName = normalizeSkillName(skill.name);
+  const skillQuery = `${skillName} ${skill.description}`;
+  return recentSpores.map((spore) => {
+    const sporeText = buildSporeSearchText(spore);
+    const descriptionScore = descriptionSimilarity(skillQuery, sporeText);
+    const nameScore = descriptionSimilarity(skillName, sporeText);
+    const totalScore = descriptionScore + nameScore * 1.5;
+    return { id: spore.id, totalScore, createdAt: spore.created_at, importance: spore.importance };
+  }).filter((candidate) => candidate.totalScore > 0).sort((a, b) => {
+    if (b.totalScore !== a.totalScore) return b.totalScore - a.totalScore;
+    if (b.importance !== a.importance) return b.importance - a.importance;
+    return b.createdAt - a.createdAt;
+  }).slice(0, SKILL_EVOLVE_RELEVANT_SPORE_LIMIT).map((candidate) => candidate.id);
+}
+async function selectRelevantSporeIdsForSkill(skill, sinceEpoch, retrievalProvider) {
+  const recentSpores = listSpores({
+    status: "active",
+    since: sinceEpoch,
+    includeActive: false,
+    limit: SKILL_EVOLVE_RECENT_SPORE_SCAN_LIMIT
+  });
+  if (recentSpores.length === 0) return [];
+  const semanticIds = await shortlistSemanticIds({
+    provider: retrievalProvider,
+    namespace: "spores",
+    query: `${normalizeSkillName(skill.name)} ${skill.description}`,
+    candidateIds: new Set(recentSpores.map((spore) => spore.id)),
+    maxResults: SKILL_EVOLVE_RELEVANT_SPORE_LIMIT,
+    overFetch: SKILL_EVOLVE_SEMANTIC_OVERFETCH,
+    threshold: SKILL_EVOLVE_SEMANTIC_THRESHOLD,
+    filters: {
+      status: "active",
+      created_at_gte: sinceEpoch
+    }
+  });
+  if (semanticIds.length > 0) return semanticIds;
+  return selectRelevantSporeIdsByLexicalOverlap(skill, recentSpores);
+}
 var MIN_SECTIONS_FOR_STANDALONE = 2;
 function extractHeadings(content) {
   const bodyMatch = content.match(/^---[\s\S]*?---\n([\s\S]*)$/);
@@ -1733,7 +1814,7 @@ function headingOverlap(headingsA, headingsB) {
   const smaller = Math.min(headingsA.length, headingsB.length);
   return { score: smaller > 0 ? shared.length / smaller : 0, shared };
 }
-function buildSkillEvolveInstruction(params, projectRoot, similarityProvider) {
+async function buildSkillEvolveInstruction(params, projectRoot, retrievalProvider) {
   const assessIntervalHours = Number(params?.assess_interval_hours ?? SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS);
   const maxSkillsPerRun = Number(params?.max_skills_per_run ?? SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN);
   const now = epochSeconds();
@@ -1750,20 +1831,20 @@ function buildSkillEvolveInstruction(params, projectRoot, similarityProvider) {
     const lastAssessedAt = typeof props.last_assessed_at === "number" ? props.last_assessed_at : 0;
     const knowledgeWatermark = typeof props.knowledge_watermark === "number" ? props.knowledge_watermark : 0;
     if (lastAssessedAt > 0 && now - lastAssessedAt < intervalSeconds) continue;
-    const newSporeIds = listSporeIdsSince(knowledgeWatermark, 10);
+    const newSporeIds = await selectRelevantSporeIdsForSkill(skill, knowledgeWatermark, retrievalProvider);
     if (newSporeIds.length === 0) continue;
     needsAssessment.push({
       id: skill.id,
       name: skill.name,
       generation: skill.generation,
       description: skill.description,
-      newSporeIds
+      newSporeIds,
+      lastAssessedAt
     });
-    if (needsAssessment.length >= maxSkillsPerRun) {
-      break;
-    }
   }
-  if (needsAssessment.length === 0) {
+  needsAssessment.sort((a, b) => a.lastAssessedAt - b.lastAssessedAt);
+  const selectedSkills = needsAssessment.slice(0, maxSkillsPerRun);
+  if (selectedSkills.length === 0) {
     return "No skills need assessment. All active skills are current or were recently assessed. Report skip via vault_report and finish.";
   }
   const structures = [];
@@ -1809,11 +1890,11 @@ function buildSkillEvolveInstruction(params, projectRoot, similarityProvider) {
     }
   }
   const parts = [
-    `${needsAssessment.length} skill(s) need assessment.`,
+    `${selectedSkills.length} skill(s) need assessment.`,
     `assess_interval_hours: ${assessIntervalHours}`,
     `max_skills_per_run: ${maxSkillsPerRun}`
   ];
-  for (const skill of needsAssessment) {
+  for (const skill of selectedSkills) {
     parts.push("");
     parts.push("---");
     parts.push(`## Skill: ${skill.name} (gen ${skill.generation})`);
@@ -1852,10 +1933,10 @@ function buildSkillEvolveInstruction(params, projectRoot, similarityProvider) {
       }
     }
   }
-  if (similarityProvider) {
+  if (retrievalProvider) {
     const idToName = new Map(allSkills.map((s) => [s.id, s.name]));
     try {
-      const semanticPairs = similarityProvider.pairwiseSimilarity("skill_records", 0.65);
+      const semanticPairs = retrievalProvider.pairwiseSimilarity("skill_records", 0.65);
       if (semanticPairs.length > 0) {
         parts.push("");
         parts.push("## Semantic Similarity (embedding cosine distance)");
@@ -1872,14 +1953,14 @@ function buildSkillEvolveInstruction(params, projectRoot, similarityProvider) {
   }
   return parts.join("\n");
 }
-async function buildTaskInstruction(taskName, taskParams, agentId, projectRoot, similarityProvider, config, getTeamClient) {
+async function buildTaskInstruction(taskName, taskParams, agentId, projectRoot, retrievalProvider, config, getTeamClient) {
   switch (taskName) {
     case SKILL_GENERATE_TASK:
       return buildSkillGenerateInstruction();
     case SKILL_SURVEY_TASK:
       return agentId ? buildSkillSurveyInstruction(agentId) : void 0;
     case SKILL_EVOLVE_TASK: {
-      const instruction = buildSkillEvolveInstruction(taskParams, projectRoot, similarityProvider);
+      const instruction = await buildSkillEvolveInstruction(taskParams, projectRoot, retrievalProvider);
       return instruction ? { instruction } : void 0;
     }
     case CORTEX_INSTRUCTIONS_TASK: {
@@ -2403,6 +2484,7 @@ var ORCHESTRATOR_GUIDANCE_HEADER = "## Orchestrator Guidance";
 var NO_CONTEXT_QUERIES_TEXT = "No context queries configured.";
 var FALLBACK_REASONING_PARSE_ERROR = "Orchestrator response could not be parsed \u2014 running all phases with defaults.";
 var FALLBACK_REASONING_MISSING_PHASES = "Orchestrator plan missing phases array \u2014 running all phases with defaults.";
+var ORCHESTRATOR_PARSE_ERROR_PREVIEW_CHARS = 200;
 var PLACEHOLDER_VAULT_STATE = "{{vault_state}}";
 var PLACEHOLDER_PHASE_DEFINITIONS = "{{phase_definitions}}";
 var PLACEHOLDER_CONTEXT_RESULTS = "{{context_results}}";
@@ -2436,7 +2518,7 @@ function composeOrchestratorPrompt(vaultState, phases, contextResults) {
   const contextSection = formatContextResults(contextResults);
   return template.replace(PLACEHOLDER_VAULT_STATE, vaultState).replace(PLACEHOLDER_PHASE_DEFINITIONS, phaseList).replace(PLACEHOLDER_CONTEXT_RESULTS, contextSection);
 }
-function parseOrchestratorPlan(response, phases) {
+function parseOrchestratorPlan(response, phases, logger) {
   const trimmed = response.trim();
   if (!trimmed) {
     return buildRunAllPlan(phases, FALLBACK_REASONING_PARSE_ERROR);
@@ -2447,8 +2529,14 @@ function parseOrchestratorPlan(response, phases) {
       return buildRunAllPlan(phases, FALLBACK_REASONING_MISSING_PHASES);
     }
     return parsed;
-  } catch {
-    return buildRunAllPlan(phases, FALLBACK_REASONING_PARSE_ERROR);
+  } catch (err) {
+    const detail = errorMessage(err);
+    const truncated = detail.length > ORCHESTRATOR_PARSE_ERROR_PREVIEW_CHARS ? `${detail.slice(0, ORCHESTRATOR_PARSE_ERROR_PREVIEW_CHARS)}\u2026` : detail;
+    logger?.warn("agent.orchestrator.parse-failed", "Orchestrator plan parse failed", {
+      error: detail,
+      responsePreview: trimmed.slice(0, 200)
+    });
+    return buildRunAllPlan(phases, `${FALLBACK_REASONING_PARSE_ERROR} (${truncated})`);
   }
 }
 function applyDirectives(phases, directives) {
@@ -3055,6 +3143,27 @@ function countWriteIntentsByToolForEvaluation(evaluationId) {
 // src/agent/tools/read-tools.ts
 import { tool } from "@anthropic-ai/claude-agent-sdk";
 
+// src/semantic-search-filters.ts
+function hasSemanticSearchFilters(filters) {
+  if (!filters) return false;
+  return Object.values(filters).some((value) => value !== void 0);
+}
+function matchesSemanticSearchFilters(metadata, filters) {
+  if (!filters) return true;
+  if (filters.status !== void 0 && metadata?.status !== filters.status) return false;
+  if (filters.session_id !== void 0 && metadata?.session_id !== filters.session_id) return false;
+  if (filters.observation_type !== void 0 && metadata?.observation_type !== filters.observation_type) return false;
+  if (filters.project_root !== void 0 && metadata?.project_root !== filters.project_root) return false;
+  if (filters.name !== void 0 && metadata?.name !== filters.name) return false;
+  if (filters.source_path !== void 0 && metadata?.source_path !== filters.source_path) return false;
+  const createdAt = typeof metadata?.created_at === "number" ? metadata.created_at : void 0;
+  if (filters.created_at_gte !== void 0 && (createdAt === void 0 || createdAt < filters.created_at_gte)) return false;
+  if (filters.created_at_lte !== void 0 && (createdAt === void 0 || createdAt > filters.created_at_lte)) return false;
+  if (filters.created_at_gt !== void 0 && (createdAt === void 0 || createdAt <= filters.created_at_gt)) return false;
+  if (filters.created_at_lt !== void 0 && (createdAt === void 0 || createdAt >= filters.created_at_lt)) return false;
+  return true;
+}
+
 // src/db/queries/graph-edges.ts
 import crypto3 from "crypto";
 var DEFAULT_BFS_DEPTH = 2;
@@ -3355,23 +3464,36 @@ function createReadTools(deps) {
   );
   const vaultSearchFts = tool(
     "vault_search_fts",
-    "Full-text search across sessions, spores, prompt batches, and activities using FTS5. Best for finding exact keywords, file paths, function names, and specific text. Results from in-flight sessions are hidden by default so intelligence tasks only see settled work; pass include_active=true to bypass.",
+    'Full-text search across sessions, spores, prompt batches, and activities using FTS5. Best for finding exact keywords, file paths, function names, and specific text. You can pass natural-language queries containing hyphens, slashes, dots, etc. \u2014 the tool auto-quotes tokens with non-word characters so file paths and hyphenated identifiers (e.g., "skill-evolve-inventory", "packages/myco/src/loader.ts") are treated as literal phrases instead of being rejected by FTS5 MATCH syntax. Plain alphanumeric/underscore tokens are left unquoted so they AND together normally. Results from in-flight sessions are hidden by default so intelligence tasks only see settled work; pass include_active=true to bypass.',
     {
-      query: external_exports.string().describe("Search query text"),
+      query: external_exports.string().describe("Search query text. Special characters (hyphens, slashes, dots, colons) are auto-quoted \u2014 no manual escaping needed."),
       type: external_exports.string().optional().describe("Restrict to a result type (session, spore, prompt_batch, activity)"),
       limit: external_exports.number().optional().describe("Maximum number of results to return"),
       include_active: external_exports.boolean().optional().describe("Include results from sessions still in active status (default: false)")
     },
     async (args) => {
+      const sanitizedQuery = sanitizeFtsQuery(args.query);
       try {
-        const results = fullTextSearch(args.query, {
+        const results = fullTextSearch(sanitizedQuery, {
           type: args.type,
           limit: args.limit ?? DEFAULT_SEARCH_LIMIT,
           includeActive: args.include_active === true
         });
-        return textResult({ results });
-      } catch {
-        return textResult({ results: [], message: "Search unavailable" });
+        return textResult({ results, sanitized_query: sanitizedQuery !== args.query ? sanitizedQuery : void 0 });
+      } catch (err) {
+        const message = errorMessage(err);
+        let hint;
+        if (/no such table|no such module: fts5/i.test(message)) {
+          hint = "FTS index missing \u2014 the searched table may not have an FTS5 mirror. Check the type parameter.";
+        } else if (/syntax error|malformed MATCH/i.test(message)) {
+          hint = 'FTS5 query syntax rejected. Quote special characters (e.g., wrap file paths in double quotes: "packages/myco/src/loader.ts").';
+        }
+        return textResult({
+          error: `vault_search_fts failed: ${message}${hint ? ` \u2014 ${hint}` : ""}`,
+          results: [],
+          query: args.query,
+          type: args.type ?? null
+        });
       }
     },
     { annotations: { readOnlyHint: true } }
@@ -3383,7 +3505,12 @@ function createReadTools(deps) {
       query: external_exports.string().describe("Search query text"),
       namespace: external_exports.string().optional().describe("Restrict to a content type: spores, sessions, plans, artifacts, skill_records. Omit to search all."),
       limit: external_exports.number().optional().describe("Maximum results to return"),
-      include_active: external_exports.boolean().optional().describe("Include results from sessions still in active status (default: false)")
+      include_active: external_exports.boolean().optional().describe("Include results from sessions still in active status (default: false)"),
+      status: external_exports.string().optional().describe("Optional metadata filter, e.g. active/superseded for spores and skill_records."),
+      session_id: external_exports.string().optional().describe("Optional metadata filter for a linked session id."),
+      observation_type: external_exports.string().optional().describe("Optional metadata filter for spore observation type."),
+      since: external_exports.number().optional().describe("Optional created_at lower bound (epoch seconds)."),
+      until: external_exports.number().optional().describe("Optional created_at upper bound (epoch seconds).")
     },
     async (args) => {
       if (!embeddingManager) {
@@ -3397,21 +3524,39 @@ function createReadTools(deps) {
         const searchLimit = args.limit ?? DEFAULT_SEARCH_LIMIT;
         const excludeActive = args.include_active !== true;
         const activeIds = excludeActive ? getActiveSessionIds() : /* @__PURE__ */ new Set();
+        const metadataFilters = {
+          ...args.status !== void 0 ? { status: args.status } : {},
+          ...args.session_id !== void 0 ? { session_id: args.session_id } : {},
+          ...args.observation_type !== void 0 ? { observation_type: args.observation_type } : {},
+          ...args.since !== void 0 ? { created_at_gte: args.since } : {},
+          ...args.until !== void 0 ? { created_at_lte: args.until } : {}
+        };
+        const vectorFilters = hasSemanticSearchFilters(metadataFilters) ? metadataFilters : void 0;
         const [rawLocalResults, teamResults] = await Promise.all([
           Promise.resolve(
             embeddingManager.searchVectors(queryVector, {
               namespace: args.namespace,
               limit: searchLimit,
-              threshold: SEARCH_SIMILARITY_THRESHOLD
+              threshold: SEARCH_SIMILARITY_THRESHOLD,
+              filters: vectorFilters
             }).map((r) => ({ ...r, source: "local" }))
           ),
-          teamClient ? teamClient.search(args.query, { limit: searchLimit }).then((res) => res.results.map((r) => ({ ...r, source: `${TEAM_SOURCE_PREFIX}${r.machine_id}` }))).catch(() => []) : Promise.resolve([])
+          teamClient ? teamClient.search(args.query, {
+            limit: searchLimit,
+            tables: args.namespace ? [args.namespace] : void 0,
+            status: args.status,
+            observation_type: args.observation_type,
+            since: args.since,
+            until: args.until,
+            session_id: args.session_id
+          }).then((res) => res.results.map((r) => ({ ...r, source: `${TEAM_SOURCE_PREFIX}${r.machine_id}` }))).catch(() => []) : Promise.resolve([])
         ]);
         const localResults = activeIds.size > 0 ? rawLocalResults.filter((r) => {
           const sid = r.metadata?.session_id;
           return typeof sid !== "string" || !activeIds.has(sid);
         }) : rawLocalResults;
-        const hydratedLocalResults = hydrateSearchResults(localResults).map((r) => ({
+        const filteredLocalResults = vectorFilters ? localResults.filter((r) => matchesSemanticSearchFilters(r.metadata, metadataFilters)) : localResults;
+        const hydratedLocalResults = hydrateSearchResults(filteredLocalResults).map((r) => ({
           ...r,
           source: "local"
         }));
@@ -3422,13 +3567,33 @@ function createReadTools(deps) {
             return typeof sid !== "string" || !activeIds.has(sid);
           });
         }
+        if (vectorFilters) {
+          dedupedTeam = dedupedTeam.filter((r) => matchesSemanticSearchFilters(
+            r.metadata,
+            metadataFilters
+          ));
+        }
         const merged = [
           ...hydratedLocalResults,
           ...dedupedTeam
         ].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, searchLimit);
         return textResult({ results: merged });
-      } catch {
-        return textResult({ results: [], message: "Semantic search unavailable" });
+      } catch (err) {
+        const message = errorMessage(err);
+        let hint;
+        if (/timeout|ETIMEDOUT|AbortError/i.test(message)) {
+          hint = "Embedding provider timed out. Retry once or reduce query length.";
+        } else if (/ECONNREFUSED|fetch failed|network/i.test(message)) {
+          hint = "Embedding provider unreachable. Check that the configured provider (Ollama/LM Studio/Anthropic) is running.";
+        } else if (/no such table|no such column/i.test(message)) {
+          hint = "Vector table missing or schema mismatch. Run `myco rebuild` or check migrations.";
+        }
+        return textResult({
+          error: `vault_search_semantic failed: ${message}${hint ? ` \u2014 ${hint}` : ""}`,
+          results: [],
+          query: args.query,
+          namespace: args.namespace ?? null
+        });
       }
     },
     { annotations: { readOnlyHint: true, openWorldHint: true } }
@@ -3636,7 +3801,8 @@ function createWriteTools(deps) {
       embeddingManager?.onContentWritten("spores", spore.id, args.content, {
         status: "active",
         observation_type: args.observation_type,
-        session_id: args.session_id
+        session_id: args.session_id,
+        created_at: now
       }).catch(() => {
       });
       return textResult(spore);
@@ -3726,12 +3892,54 @@ function createWriteTools(deps) {
   );
   const vaultReadDigest = tool2(
     "vault_read_digest",
-    "Read current digest extracts. Without a tier parameter, returns a summary of all tiers (content length, generation time). With a tier parameter, returns the full content for that specific tier.",
+    'Read current digest extracts. Three modes: (1) no args \u2192 summary metadata for all tiers; (2) tier \u2192 full content for that tier; (3) pick: "rotate_oldest" \u2192 the digest-rotation decision, returning the tier whose generated_at is oldest plus its full content (or skip:true when all tiers are fresher than min_staleness_seconds). The rotation mode lets callers outsource the "which tier should we update this run" choice to a deterministic tool decision instead of prompting the LLM to compare timestamps.',
     {
-      tier: external_exports.number().optional().describe("Specific tier to read in full (e.g., 1500, 5000, 10000). Omit to get summary of all tiers.")
+      tier: external_exports.number().optional().describe("Specific tier to read in full (e.g., 1500, 5000, 10000). Omit to get summary of all tiers. Ignored when pick is set."),
+      pick: external_exports.enum(["rotate_oldest"]).optional().describe('Rotation mode. "rotate_oldest" picks the tier with the oldest generated_at (missing tiers count as never-generated and sort first). The response includes the selected tier, its full content, a rotation_reason explaining the choice, and metadata for all tiers so the caller can audit the decision.'),
+      min_staleness_seconds: external_exports.number().optional().describe(`Used with pick="rotate_oldest". If every tier's generated_at is newer than (now - min_staleness_seconds), the tool returns {skip: true, reason, all_tiers} instead of selecting a tier. Defaults to 0 (never skip).`)
     },
     async (args) => {
       const extracts = listDigestExtracts(agentId);
+      if (args.pick === "rotate_oldest") {
+        const now = epochSeconds();
+        const canonical = DIGEST_TIERS.map((tier) => {
+          const existing = extracts.find((e) => e.tier === tier);
+          return {
+            tier,
+            generated_at: existing?.generated_at ?? 0,
+            content_length: existing?.content.length ?? 0,
+            content: existing?.content ?? null
+          };
+        });
+        const minStale = args.min_staleness_seconds ?? 0;
+        if (minStale > 0) {
+          const allPresent = canonical.every((t) => t.generated_at > 0);
+          const cutoff = now - minStale;
+          const allFresh = canonical.every((t) => t.generated_at > cutoff);
+          if (allPresent && allFresh) {
+            return textResult({
+              mode: "rotate_oldest",
+              skip: true,
+              reason: `All ${canonical.length} tiers were generated within the last ${minStale} seconds (cutoff=${cutoff}).`,
+              all_tiers: canonical.map((t) => ({ tier: t.tier, generated_at: t.generated_at, content_length: t.content_length }))
+            });
+          }
+        }
+        const sorted = [...canonical].sort((a, b) => {
+          if (a.generated_at !== b.generated_at) return a.generated_at - b.generated_at;
+          return b.tier - a.tier;
+        });
+        const selected = sorted[0];
+        const reason = selected.generated_at === 0 ? `Tier ${selected.tier} has never been generated \u2014 seeding.` : `Tier ${selected.tier} has the oldest generated_at (${selected.generated_at}); next oldest is tier ${sorted[1]?.tier} at ${sorted[1]?.generated_at}.`;
+        return textResult({
+          mode: "rotate_oldest",
+          selected_tier: selected.tier,
+          selected_generated_at: selected.generated_at,
+          selected_content: selected.content,
+          rotation_reason: reason,
+          all_tiers: canonical.map((t) => ({ tier: t.tier, generated_at: t.generated_at, content_length: t.content_length }))
+        });
+      }
       if (args.tier !== void 0) {
         const extract = extracts.find((e) => e.tier === args.tier);
         if (!extract) return textResult({ tier: args.tier, content: null, message: "No digest at this tier" });
@@ -4131,7 +4339,7 @@ function createSkillTools(deps) {
         );
       }
       try {
-        const { syncSkillSymlinks } = await import("./installer-UMH7OJ5A.js");
+        const { syncSkillSymlinks } = await import("./installer-N4UTEACX.js");
         syncSkillSymlinks(root, params.name, { remove: true });
       } catch (rollbackErr) {
         console.warn(
@@ -4149,7 +4357,7 @@ function createSkillTools(deps) {
       };
     }
     try {
-      const { syncSkillSymlinks } = await import("./installer-UMH7OJ5A.js");
+      const { syncSkillSymlinks } = await import("./installer-N4UTEACX.js");
       syncSkillSymlinks(root, params.name);
     } catch (err) {
       console.warn(
@@ -4351,14 +4559,15 @@ function createSkillTools(deps) {
   );
   const vaultSkillRecords = tool4(
     "vault_skill_records",
-    "Read, update, and delete skill records (materialized skills on disk). Supports list, get, update, and delete actions. The get action includes the full SKILL.md file content.",
+    "Read, update, and delete skill records (materialized skills on disk). Supports list, get, update, and delete actions. The get action includes the full SKILL.md file content. For update, at least one mutating field (status, generation, source_ids, description, or properties) is required \u2014 calls with only {action, id} are rejected to prevent silent no-op updates.",
     {
       action: external_exports.enum(["list", "get", "update", "delete"]).describe("Action to perform"),
       id: external_exports.string().optional().describe("Skill record ID or name (required for get/update/delete)"),
-      status: external_exports.enum(["active", "stale", "retired"]).optional().describe("Filter by status"),
+      status: external_exports.enum(["active", "stale", "retired"]).optional().describe("Filter by status or new status (for update)"),
       generation: external_exports.number().optional().describe("New generation number (for update)"),
       source_ids: external_exports.string().optional().describe("JSON array of source IDs (for update)"),
       description: external_exports.string().optional().describe("Updated description (for update)"),
+      properties: external_exports.string().optional().describe(`JSON-encoded object of properties to MERGE into the existing properties (for update). Example: '{"last_verified_at": 1776580022}'. Existing keys not included in the payload are preserved; included keys overwrite. Used by skill-evolve to persist watermarks like last_assessed_at, knowledge_watermark, last_verified_at, last_classification.`),
       limit: external_exports.number().optional().describe("Maximum records to return (for list)")
     },
     async (args) => {
@@ -4386,14 +4595,44 @@ function createSkillTools(deps) {
         }
         case "update": {
           if (!args.id) return textResult({ error: "id is required for update action" });
+          const hasMutatingField = args.status !== void 0 || args.generation !== void 0 || args.source_ids !== void 0 || args.description !== void 0 || args.properties !== void 0;
+          if (!hasMutatingField) {
+            return textResult({
+              error: "update action requires at least one mutating field (status, generation, source_ids, description, or properties). Calls with only {action, id} are rejected to prevent silent no-op updates."
+            });
+          }
           const existing = getSkillRecord(args.id) ?? getSkillRecordByName(args.id);
           if (!existing) return textResult({ error: `Skill record not found: ${args.id}` });
+          let mergedProperties;
+          if (args.properties !== void 0) {
+            let incoming;
+            try {
+              const parsed = JSON.parse(args.properties);
+              if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return textResult({ error: "properties must be a JSON-encoded object (not null, array, or primitive)." });
+              }
+              incoming = parsed;
+            } catch (err) {
+              return textResult({ error: `properties is not valid JSON: ${errorMessage(err)}` });
+            }
+            let existingProps = {};
+            try {
+              const parsedExisting = JSON.parse(existing.properties || "{}");
+              if (parsedExisting && typeof parsedExisting === "object" && !Array.isArray(parsedExisting)) {
+                existingProps = parsedExisting;
+              }
+            } catch (err) {
+              console.warn(`[vault_skill_records] Skill ${existing.id} has unparseable properties; treating as empty for merge. Error: ${errorMessage(err)}`);
+            }
+            mergedProperties = JSON.stringify({ ...existingProps, ...incoming });
+          }
           const now = epochSeconds();
           const updated = updateSkillRecord(existing.id, {
             ...args.status !== void 0 ? { status: args.status } : {},
             ...args.generation !== void 0 ? { generation: args.generation } : {},
             ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
             ...args.description !== void 0 ? { description: args.description } : {},
+            ...mergedProperties !== void 0 ? { properties: mergedProperties } : {},
             updated_at: now
           });
           if (!updated) return textResult({ error: `Failed to update skill record: ${existing.id}` });
@@ -4416,7 +4655,7 @@ function createSkillTools(deps) {
               console.warn("[vault_skill_records] Failed to remove skill directory:", err instanceof Error ? err.message : err);
             }
             try {
-              const { syncSkillSymlinks } = await import("./installer-UMH7OJ5A.js");
+              const { syncSkillSymlinks } = await import("./installer-N4UTEACX.js");
               syncSkillSymlinks(root, result.name, { remove: true });
             } catch (err) {
               console.warn("[vault_skill_records] Failed to remove symlinks:", err instanceof Error ? err.message : err);
@@ -4534,7 +4773,7 @@ function createSkillTools(deps) {
         return textResult({ error: `Failed to write skill file: ${err instanceof Error ? err.message : String(err)}` });
       }
       try {
-        const { syncSkillSymlinks } = await import("./installer-UMH7OJ5A.js");
+        const { syncSkillSymlinks } = await import("./installer-N4UTEACX.js");
         syncSkillSymlinks(root, args.name);
       } catch (err) {
         console.warn("[vault_write_skill] syncSkillSymlinks failed:", err instanceof Error ? err.message : err);
@@ -5116,19 +5355,34 @@ function truncateSummary(text) {
   if (!text) return null;
   return text.length > TOOL_OUTPUT_SUMMARY_LIMIT ? `${text.slice(0, TOOL_OUTPUT_SUMMARY_LIMIT - 1)}\u2026` : text;
 }
+var TOOL_ERROR_PREFIX = "[ERROR] ";
+function isErrorResult(result) {
+  if (!result || typeof result !== "object") return false;
+  const content = result.content;
+  if (!Array.isArray(content) || content.length === 0) return false;
+  const first = content[0];
+  if (!first || first.type !== "text" || typeof first.text !== "string") return false;
+  const trimmed = first.text.trimStart();
+  if (!trimmed.startsWith("{")) return false;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return !!parsed && typeof parsed === "object" && "error" in parsed && parsed.error !== void 0;
+  } catch {
+    return false;
+  }
+}
 function summarizeToolResult(result) {
   if (!result || typeof result !== "object") return null;
   const content = result.content;
   if (!Array.isArray(content) || content.length === 0) return null;
   const first = content[0];
   if (!first || first.type !== "text" || typeof first.text !== "string") return null;
-  return truncateSummary(first.text.replace(/\s+/g, " ").trim());
+  const body = first.text.replace(/\s+/g, " ").trim();
+  const prefix = isErrorResult(result) ? TOOL_ERROR_PREFIX : "";
+  return truncateSummary(prefix + body);
 }
 function summarizeToolError(error) {
-  if (error instanceof Error && error.message) {
-    return truncateSummary(error.message) ?? "Tool failed";
-  }
-  return truncateSummary(String(error)) ?? "Tool failed";
+  return truncateSummary(TOOL_ERROR_PREFIX + errorMessage(error)) ?? TOOL_ERROR_PREFIX + "Tool failed";
 }
 function buildRepeatedReadSuppressionResult(toolName, repeatedCalls) {
   return {
@@ -5265,6 +5519,7 @@ function createVaultTools(agentId, runId, options) {
   }
   function wrapToolWithAudit(toolDef) {
     const originalHandler = toolDef.handler;
+    const declaredKeys = toolDef.inputSchema && typeof toolDef.inputSchema === "object" ? new Set(Object.keys(toolDef.inputSchema)) : /* @__PURE__ */ new Set();
     return {
       ...toolDef,
       handler: async (args, extra) => {
@@ -5272,6 +5527,28 @@ function createVaultTools(agentId, runId, options) {
         const priorIdenticalCalls = repeatedReadKey ? repeatedReadCounts.get(repeatedReadKey) ?? 0 : 0;
         const turnId = recordTurn(toolDef.name, args);
         try {
+          if (declaredKeys.size > 0 && args && typeof args === "object") {
+            const unknown = [];
+            for (const key of Object.keys(args)) {
+              if (!declaredKeys.has(key)) unknown.push(key);
+            }
+            if (unknown.length > 0) {
+              const accepted = Array.from(declaredKeys).sort().join(", ");
+              const result2 = textResult({
+                error: `Unknown parameter(s) for ${toolDef.name}: ${unknown.join(", ")}. Accepted parameters: ${accepted}.`
+              });
+              if (turnId !== null) {
+                try {
+                  updateTurn(turnId, {
+                    tool_output_summary: summarizeToolResult(result2),
+                    completed_at: epochSeconds()
+                  });
+                } catch {
+                }
+              }
+              return result2;
+            }
+          }
           if (priorIdenticalCalls >= REPEATED_READ_FAILURE_THRESHOLD) {
             throw new Error(
               `Repeated identical ${toolDef.name} reads detected (${priorIdenticalCalls + 1} calls). Reuse the prior result already in context and proceed to a write, report, or different query.`
@@ -5405,6 +5682,13 @@ function getIsolatedPluginCacheDir() {
   if (isolatedPluginCacheDir) return isolatedPluginCacheDir;
   const dir = path3.join(os.tmpdir(), `myco-agent-plugin-cache-${process.pid}`);
   fs3.mkdirSync(dir, { recursive: true });
+  const manifestPath = path3.join(dir, "installed_plugins.json");
+  if (!fs3.existsSync(manifestPath)) {
+    fs3.writeFileSync(
+      manifestPath,
+      JSON.stringify({ version: 2, plugins: {} })
+    );
+  }
   isolatedPluginCacheDir = dir;
   return dir;
 }
@@ -5450,6 +5734,18 @@ var ClaudeSdkRuntime = class {
       // user hasn't explicitly overridden the cache dir themselves.
       CLAUDE_CODE_PLUGIN_CACHE_DIR: process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR ?? getIsolatedPluginCacheDir()
     };
+    if (input.logger) {
+      const mcpToolNames = input.toolSurface.toolNames ?? (toolServer ? ["<full-vault-surface>"] : []);
+      input.logger.debug("agent.runtime.request", "Agent runtime request", {
+        runId: input.toolSurface.runId,
+        agentId: input.toolSurface.agentId,
+        model: input.model,
+        mcpToolCount: mcpToolNames.length,
+        mcpTools: mcpToolNames,
+        pluginCacheDir: env.CLAUDE_CODE_PLUGIN_CACHE_DIR,
+        sessionRef: input.sessionRef ?? null
+      });
+    }
     let finalText = "";
     let turnsUsed = 0;
     let inputTokens = 0;
@@ -5464,6 +5760,7 @@ var ClaudeSdkRuntime = class {
         tools: [],
         mcpServers: toolServer ? { [MCP_SERVER_NAME]: toolServer } : {},
         strictMcpConfig: true,
+        settingSources: [],
         maxTurns: input.maxTurns,
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
@@ -5504,7 +5801,7 @@ var ClaudeSdkRuntime = class {
     } catch (err) {
       if (turnsUsed > 0 || inputTokens > 0 || outputTokens > 0) {
         throw new RuntimeExecutionError(
-          err instanceof Error ? err.message : String(err),
+          errorMessage(err),
           { usage: buildUsage(), sessionRef: input.sessionRef },
           { cause: err }
         );
@@ -13069,7 +13366,17 @@ function getAgentRuntime(runtimeId) {
 // src/agent/phase-loop.ts
 async function executePhase(input) {
   const { ctx, phasePrompt, phaseModel, phase, toolSurface, provider, sessionId, sessionData } = input;
+  const logger = ctx.options?.logger;
   const runtime = getAgentRuntime(ctx.config.runtime);
+  logger?.debug("agent.phase.start", `Phase ${phase.name} starting`, {
+    runId: ctx.runId,
+    phase: phase.name,
+    model: phaseModel,
+    maxTurns: phase.maxTurns,
+    required: phase.required ?? false,
+    toolNames: toolSurface.toolNames ?? null,
+    sessionRef: sessionId ?? null
+  });
   try {
     let result;
     try {
@@ -13082,13 +13389,19 @@ async function executePhase(input) {
         sessionRef: sessionId,
         sessionData,
         abortController: ctx.abortController,
-        toolSurface
+        toolSurface,
+        logger
       });
     } catch (error) {
-      if (!sessionId || !runtime.supports("supportsSessionResume") || !isSessionResumeFailure(error)) {
+      if (!sessionId || !runtime.supports("supportsSessionResume") || !isSessionResumeFailure(error) && !isExpiredSessionError(error)) {
         throw error;
       }
-      console.warn(`[agent] Resuming phase "${phase.name}" session failed, retrying without prior session`);
+      logger?.info("agent.phase.session-retry", `Phase ${phase.name} session failed, retrying without prior session`, {
+        runId: ctx.runId,
+        phase: phase.name,
+        priorSession: sessionId,
+        error: errorMessage(error)
+      });
       result = await runtime.execute({
         prompt: phasePrompt,
         model: phaseModel,
@@ -13096,14 +13409,24 @@ async function executePhase(input) {
         systemPrompt: ctx.systemPrompt,
         provider,
         abortController: ctx.abortController,
-        toolSurface
+        toolSurface,
+        logger
       });
     }
-    if (phase.maxTurns && result.turnsUsed > 0) {
-      console.log(`[agent] Phase "${phase.name}": num_turns=${result.turnsUsed}, budget=${phase.maxTurns}`);
-    }
+    logger?.debug("agent.phase.end", `Phase ${phase.name} finished`, {
+      runId: ctx.runId,
+      phase: phase.name,
+      status: "completed",
+      turnsUsed: result.turnsUsed,
+      maxTurns: phase.maxTurns ?? null,
+      tokensUsed: result.usage.totalTokens ?? 0,
+      costUsd: result.usage.costUsd ?? null
+    });
     if (phase.required && result.turnsUsed === 0) {
-      console.warn(`[agent] Required phase "${phase.name}" produced 0 turns`);
+      logger?.warn("agent.phase.zero-turns", `Required phase ${phase.name} produced 0 turns`, {
+        runId: ctx.runId,
+        phase: phase.name
+      });
     }
     const costData = await resolveCost({
       runtime: ctx.config.runtime,
@@ -13129,6 +13452,15 @@ async function executePhase(input) {
       model: phaseModel,
       usage: telemetry.usage
     }) : void 0;
+    logger?.debug("agent.phase.end", `Phase ${phase.name} failed`, {
+      runId: ctx.runId,
+      phase: phase.name,
+      status: "failed",
+      turnsUsed: telemetry?.usage.requests ?? 0,
+      tokensUsed: telemetry?.usage.totalTokens ?? 0,
+      costUsd: telemetry?.usage.costUsd ?? null,
+      error: abortReason ?? errorMessage(err)
+    });
     return buildPhaseResult({
       name: phase.name,
       status: "failed",
@@ -13146,23 +13478,41 @@ async function executeSingleQuery(ctx, taskPrompt, provider, sessionRef, session
     provider,
     ctx.config.model
   );
-  const result = await runtime.execute({
+  const toolSurface = {
+    agentId: ctx.agentId,
+    runId: ctx.runId,
+    vaultDir: ctx.vaultDir,
+    embeddingManager: ctx.embeddingManager,
+    dryRun: ctx.config.dryRun ?? false
+  };
+  const baseInput = {
     prompt: taskPrompt,
     model: effectiveModel,
     maxTurns: ctx.config.maxTurns,
     systemPrompt: ctx.systemPrompt,
     provider,
     abortController: ctx.abortController,
-    sessionRef,
-    sessionData,
-    toolSurface: {
-      agentId: ctx.agentId,
-      runId: ctx.runId,
-      vaultDir: ctx.vaultDir,
-      embeddingManager: ctx.embeddingManager,
-      dryRun: ctx.config.dryRun ?? false
+    toolSurface,
+    logger: ctx.options?.logger
+  };
+  let result;
+  try {
+    result = await runtime.execute({ ...baseInput, sessionRef, sessionData });
+  } catch (err) {
+    if (!sessionRef || !runtime.supports("supportsSessionResume") || !isSessionResumeFailure(err) && !isExpiredSessionError(err)) {
+      throw err;
     }
-  });
+    ctx.options?.logger?.info(
+      "agent.single-query.session-retry",
+      "Single-query session failed, retrying without prior session",
+      {
+        runId: ctx.runId,
+        priorSession: sessionRef,
+        error: errorMessage(err)
+      }
+    );
+    result = await runtime.execute(baseInput);
+  }
   const costData = await resolveCost({
     runtime: ctx.config.runtime,
     provider,
@@ -13210,10 +13560,17 @@ async function executePhasedQuery(ctx) {
         vaultDir: ctx.vaultDir,
         dryRun: config.dryRun ?? false
       },
-      abortController: ctx.abortController
+      abortController: ctx.abortController,
+      logger: ctx.options?.logger
     });
-    const plan = parseOrchestratorPlan(planResponse.finalText, phases);
+    const plan = parseOrchestratorPlan(planResponse.finalText, phases, ctx.options?.logger);
     effectivePhases = applyDirectives(phases, plan.phases);
+    ctx.options?.logger?.debug("agent.orchestrator.plan", "Orchestrator plan applied", {
+      runId,
+      reasoning: plan.reasoning,
+      effectivePhases: effectivePhases.map((p) => p.name),
+      skippedPhases: plan.phases.filter((d) => d.skip).map((d) => d.name)
+    });
   }
   const declarationOrder = new Map(phases.map((p, i) => [p.name, i]));
   const waves = computeWaves(effectivePhases);
@@ -13373,12 +13730,16 @@ var SKIP_REASON_ALREADY_RUNNING = "already_running";
 var CORTEX_INSTRUCTIONS_REPORT_ACTION = "cortex_instructions";
 var CORTEX_INSTRUCTIONS_CONTENT_KEY = "content";
 var TOKEN_BUDGET_PRESSURE_STATUSES = /* @__PURE__ */ new Set(["warning", "post_run_pressure"]);
-function logTokenBudgetPressure(taskName, usage, provider) {
+function logTokenBudgetPressure(taskName, usage, provider, logger) {
   const budget = analyzeRuntimeTokenBudget(usage, provider);
   if (!TOKEN_BUDGET_PRESSURE_STATUSES.has(budget.status)) return;
-  console.warn(
-    `[agent] ${taskName} token budget ${budget.status}: ${budget.utilizationPercent}% of ${budget.contextWindowTokens} tokens at peak request (${budget.peakRequestTotalTokens} tokens)`
-  );
+  logger?.warn("agent.token-budget-pressure", `${taskName} token budget ${budget.status}`, {
+    task: taskName,
+    status: budget.status,
+    utilizationPercent: budget.utilizationPercent,
+    contextWindowTokens: budget.contextWindowTokens,
+    peakRequestTotalTokens: budget.peakRequestTotalTokens
+  });
 }
 async function runAgent(vaultDir, options) {
   const db = initDatabase(vaultDbPath(vaultDir));
@@ -13523,15 +13884,25 @@ async function runAgent(vaultDir, options) {
     taskProviderOverride = resolved.taskProvider;
     phaseProviderOverrides = resolved.phaseOverrides;
     for (const conflict of resolved.conflicts) {
-      console.warn(
-        `[agent] Ollama model "${conflict.model}" referenced with conflicting context_length values [${conflict.values.join(", ")}] \u2014 reconciled to ${conflict.resolved} to avoid loading multiple variants. Configure one value per model to silence this warning.`
+      options?.logger?.warn(
+        "agent.ollama.context-variant-conflict",
+        `Ollama model "${conflict.model}" referenced with conflicting context_length values \u2014 reconciled to ${conflict.resolved}`,
+        {
+          model: conflict.model,
+          values: conflict.values,
+          resolved: conflict.resolved
+        }
       );
     }
   }
   const taskAbortController = new AbortController();
   const timeoutMs = config.timeoutSeconds * MS_PER_SECOND;
   const timeoutId = setTimeout(() => {
-    console.warn(`[agent] Run ${runId} exceeded timeout (${config.timeoutSeconds}s), aborting`);
+    options?.logger?.warn("agent.run.timeout", `Run ${runId} exceeded timeout, aborting`, {
+      runId,
+      taskName: config.taskName,
+      timeoutSeconds: config.timeoutSeconds
+    });
     taskAbortController.abort(new Error(`Agent run timed out after ${config.timeoutSeconds} seconds`));
   }, timeoutMs);
   timeoutId.unref?.();
@@ -13623,13 +13994,14 @@ async function runAgent(vaultDir, options) {
       }
     }
     clearTimeout(timeoutId);
-    logTokenBudgetPressure(config.taskName, usage, effectiveProvider);
+    logTokenBudgetPressure(config.taskName, usage, effectiveProvider, options?.logger);
     await finalizeOnTaskSuccess({
       taskName: config.taskName,
       agentId,
       runId,
       runContext: options?.runContext,
-      instruction: options?.instruction
+      instruction: options?.instruction,
+      dryRun: options?.dryRun
     });
     const completedAt = epochSeconds();
     updateRunStatus(runId, STATUS_COMPLETED, {
@@ -13677,34 +14049,48 @@ ${err.stack.split("\n").slice(0, 3).join("\n")}`;
       }
     }
     const failedAt = epochSeconds();
-    console.error(`[agent] Run ${runId} failed: ${errorMessage2}`);
+    options?.logger?.error("agent.run.failed", `Run ${runId} failed`, {
+      runId,
+      taskName: config.taskName,
+      error: errorMessage2
+    });
     try {
       const usage = aggregateUsage(phaseResults?.map((phase) => phase.usage) ?? []);
-      logTokenBudgetPressure(config.taskName, usage, effectiveProvider);
+      logTokenBudgetPressure(config.taskName, usage, effectiveProvider, options?.logger);
       const costData = phaseResults ? summarizePhaseCosts(phaseResults) : await resolveCost({
         runtime: runtimeId,
         provider: effectiveProvider,
         model: effectiveModel,
         usage
       });
+      const hadPriorSession = Boolean(checkpointState.sessionRef) || Object.values(checkpointState.phases).some((phase) => Boolean(phase.sessionRef));
+      const recordedAnyTurns = (usage.requests ?? 0) > 0 || (phaseResults?.some((phase) => phase.turnsUsed > 0) ?? false);
+      const sessionExpired = Boolean(options?.resumeRunId) && hadPriorSession && !recordedAnyTurns && isExpiredSessionError(err);
+      const accountingUpdate = buildRunAccountingUpdate({
+        runtime: runtimeId,
+        provider: effectiveProvider,
+        model: effectiveModel,
+        checkpointState,
+        usage,
+        costData,
+        phaseResults
+      });
+      if (sessionExpired) {
+        accountingUpdate.checkpoints = null;
+      }
       updateRunStatus(runId, STATUS_FAILED, {
-        resumable: 1,
-        resume_status: RESUME_STATUS_READY,
+        resumable: sessionExpired ? 0 : 1,
+        resume_status: sessionExpired ? RESUME_STATUS_SESSION_EXPIRED : RESUME_STATUS_READY,
         completed_at: failedAt,
         tokens_used: usage.totalTokens ?? phaseResults?.reduce((sum, phase) => sum + phase.tokensUsed, 0) ?? void 0,
         error: errorMessage2,
-        ...buildRunAccountingUpdate({
-          runtime: runtimeId,
-          provider: effectiveProvider,
-          model: effectiveModel,
-          checkpointState,
-          usage,
-          costData,
-          phaseResults
-        })
+        ...accountingUpdate
       });
     } catch (dbErr) {
-      console.error(`[agent] Failed to save error to DB:`, dbErr);
+      options?.logger?.error("agent.run.db-save-failed", `Failed to save error to DB for run ${runId}`, {
+        runId,
+        error: errorMessage(dbErr)
+      });
     }
     await cleanupOnTaskFailure({
       taskName: config.taskName,
@@ -13742,6 +14128,7 @@ async function cleanupOnTaskFailure(args) {
 }
 async function finalizeOnTaskSuccess(args) {
   if (args.taskName !== CORTEX_INSTRUCTIONS_TASK) return;
+  if (args.dryRun) return;
   const reports = listReports(args.runId);
   let report;
   for (let i = reports.length - 1; i >= 0; i -= 1) {
@@ -13832,6 +14219,8 @@ export {
   countWriteIntents,
   countWriteIntentsByTool,
   countWriteIntentsByToolForEvaluation,
+  hasSemanticSearchFilters,
+  matchesSemanticSearchFilters,
   getGraphForNode,
   createBatchLineage,
   insertResolutionEvent,
@@ -13841,4 +14230,4 @@ export {
   cleanupOnTaskFailure,
   finalizeOnTaskSuccess
 };
-//# sourceMappingURL=chunk-NGH7U6A3.js.map
+//# sourceMappingURL=chunk-HCT7RMM2.js.map