@mhingston5/lasso 0.1.0

package/src/failures/recovery.ts

@@ -0,0 +1,214 @@
+import type { FailureSignature, FailureContext } from "./ontology.js";
+
+export interface RecoveryStep {
+  action: string;
+  description: string;
+  automated: boolean;
+}
+
+export interface RecoveryPlan {
+  steps: RecoveryStep[];
+  estimatedSuccessRate: number;
+  requiresHumanApproval: boolean;
+}
+
+const AUTH_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Refresh authentication credentials",
+    description: "Attempt to refresh or re-obtain the expired/invalid credentials",
+    automated: false,
+  },
+  {
+    action: "Verify API key configuration",
+    description: "Check that API keys and secrets are correctly set in the environment",
+    automated: true,
+  },
+  {
+    action: "Check token expiry",
+    description: "Inspect the current token's expiry time and renew if necessary",
+    automated: true,
+  },
+];
+
+const TOOL_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Check tool availability",
+    description: "Verify the required tool is installed and accessible in PATH",
+    automated: true,
+  },
+  {
+    action: "Install missing tool",
+    description: "Install the required tool if it is not present",
+    automated: false,
+  },
+  {
+    action: "Verify tool version",
+    description: "Check that the tool version is compatible with expected version",
+    automated: true,
+  },
+];
+
+const RESOURCE_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Check disk space",
+    description: "Verify available disk space and clean up temporary files if needed",
+    automated: true,
+  },
+  {
+    action: "Free up memory",
+    description: "Release unused memory or increase memory limits",
+    automated: false,
+  },
+  {
+    action: "Apply rate limiting",
+    description: "Implement backoff strategy to avoid hitting rate limits",
+    automated: true,
+  },
+];
+
+const SEMANTIC_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Validate output format",
+    description: "Check the output against the expected schema or format",
+    automated: true,
+  },
+  {
+    action: "Review input data",
+    description: "Verify input data is correct and complete",
+    automated: true,
+  },
+  {
+    action: "Add validation step",
+    description: "Insert a validation node before processing to catch format errors early",
+    automated: false,
+  },
+];
+
+const HUMAN_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Escalate to human operator",
+    description: "Notify a human operator to review and make a decision",
+    automated: false,
+  },
+  {
+    action: "Provide additional context",
+    description: "Gather more information to help the human make an informed decision",
+    automated: true,
+  },
+  {
+    action: "Reconsider proposed changes",
+    description: "Review and potentially modify the changes that were rejected",
+    automated: false,
+  },
+];
+
+const ENVIRONMENT_DRIFT_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Sync environment dependencies",
+    description: "Install or update dependencies to match expected versions",
+    automated: false,
+  },
+  {
+    action: "Verify configuration",
+    description: "Check that environment configuration matches expected state",
+    automated: true,
+  },
+  {
+    action: "Update version requirements",
+    description: "Align version requirements with the actual environment",
+    automated: false,
+  },
+];
+
+const NETWORK_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Retry with exponential backoff",
+    description: "Retry the failed operation with increasing delays between attempts",
+    automated: true,
+  },
+  {
+    action: "Check network connectivity",
+    description: "Verify DNS resolution and network reachability to the target",
+    automated: true,
+  },
+  {
+    action: "Verify target service health",
+    description: "Check if the target service is up and responding",
+    automated: true,
+  },
+];
+
+const UNKNOWN_RECOVERY_STEPS: RecoveryStep[] = [
+  {
+    action: "Collect diagnostic information",
+    description: "Gather logs, metrics, and traces to understand the failure",
+    automated: true,
+  },
+  {
+    action: "Review error logs",
+    description: "Examine detailed error logs for root cause clues",
+    automated: true,
+  },
+  {
+    action: "Escalate to human operator",
+    description: "If automated diagnostics fail, escalate for human investigation",
+    automated: false,
+  },
+];
+
+const CLASS_RECOVERY_MAP: Record<FailureSignature["class"], RecoveryStep[]> = {
+  auth: AUTH_RECOVERY_STEPS,
+  tool: TOOL_RECOVERY_STEPS,
+  resource: RESOURCE_RECOVERY_STEPS,
+  semantic: SEMANTIC_RECOVERY_STEPS,
+  human: HUMAN_RECOVERY_STEPS,
+  "environment-drift": ENVIRONMENT_DRIFT_RECOVERY_STEPS,
+  network: NETWORK_RECOVERY_STEPS,
+  unknown: UNKNOWN_RECOVERY_STEPS,
+};
+
+const CLASS_BASE_SUCCESS_RATE: Record<FailureSignature["class"], number> = {
+  auth: 0.3,
+  tool: 0.5,
+  resource: 0.4,
+  semantic: 0.3,
+  human: 0.2,
+  "environment-drift": 0.4,
+  network: 0.7,
+  unknown: 0.1,
+};
+
+export function suggestRecovery(
+  signature: FailureSignature,
+  context?: FailureContext,
+): RecoveryPlan {
+  const baseSteps = CLASS_RECOVERY_MAP[signature.class];
+  const steps = [...baseSteps];
+
+  if (context?.attemptNumber !== undefined && context.attemptNumber > 3) {
+    steps.push({
+      action: "Escalate after repeated failures",
+      description: `Failure has occurred ${context.attemptNumber} times, escalate to human`,
+      automated: false,
+    });
+  }
+
+  const baseRate = CLASS_BASE_SUCCESS_RATE[signature.class];
+  const confidenceAdjustment = signature.confidence * 0.2;
+  const retryableBonus = signature.retryable ? 0.15 : 0;
+  const estimatedSuccessRate = Math.min(1, baseRate + confidenceAdjustment + retryableBonus);
+
+  const requiresHumanApproval =
+    signature.requiresHumanIntervention ||
+    signature.class === "semantic" ||
+    signature.class === "environment-drift" ||
+    signature.class === "unknown" ||
+    (signature.class === "resource" &&
+      signature.evidence.some((e) => e.toLowerCase().includes("memory")));
+
+  return {
+    steps,
+    estimatedSuccessRate: Math.round(estimatedSuccessRate * 100) / 100,
+    requiresHumanApproval,
+  };
+}

package/src/failures/types.ts

@@ -0,0 +1,14 @@
+export interface FailureRecord {
+  domainType: string;
+  rootCause:
+    | "tool_timeout"
+    | "auth_required"
+    | "rate_limited"
+    | "invalid_output"
+    | "dependency_failure"
+    | "verification_failed"
+    | "human_block"
+    | "unknown";
+  nodeId?: string;
+  message: string;
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+export type { HarnessSpec, TaskNode, TaskGraph, TaskEdge, ExecutionPolicy, RetryPolicy, VerificationPolicy, HumanPolicy, ObservabilityPolicy } from "./spec/types.js";
+export type { CirWorkflow, CirNode, CirTransition, CirExecutionPolicy } from "./cir/types.js";
+export type { CompiledHarnessWorkflow, CompiledHarnessResult } from "./compiler/compile.js";
+export type { LocalPrBundle } from "./reference/types.js";
+export type { PlannerResult, WorkflowTemplate, ExtractionResult } from "./planner/types.js";
+export type {
+  ReplanAbortReason,
+  ReplanRequest,
+  ReplanResult,
+  ReplanTrigger,
+  ReplanWorkflow,
+  RiskLevel,
+} from "./replanner/types.js";
+export type { FailureRecord } from "./failures/types.js";
+export type { HarnessState } from "./state/types.js";
+export type { IntentIR, IntentParseResult, SupportedWorkflowFamily } from "./synthesis/intent-ir.js";
+export type { TaskGraph as SynthesisTaskGraph, WorkflowStage } from "./synthesis/graph-builder.js";
+export type { RiskModel, StageRisk } from "./synthesis/risk-analyzer.js";
+export type { PolicyBundle, PolicyResult } from "./synthesis/policy-builder.js";
+export type { HarnessVersion, LineageEntry, HarnessExecutionTrace } from "./versioning/types.js";
+export type { LineageStore, LineageFilter } from "./versioning/store.js";
+export { FileLineageStore } from "./versioning/file-store.js";
+export type { AdaptiveRuntimeMetadata, AdaptiveRuntimeInput, RuntimeReplanDecision } from "./replanner/runtime.js";
+export { validateHarnessSpec } from "./spec/validate.js";
+export { lowerHarnessSpecToCir } from "./cir/lower.js";
+export { compileHarnessSpec } from "./compiler/compile.js";
+export { planWorkflowRequest } from "./planner/synthesize.js";
+export { parseReplanRequest, replanWorkflowRequest } from "./replanner/synthesize.js";
+export { buildPrReviewMergeHarnessSpec } from "./reference/pr-review-merge.js";
+export { createLassoCommands, clearCompiledHarnesses } from "./pi/commands.js";
+export { classifyFailureRecord, isRetryableFailure } from "./failures/ontology.js";
+export { mapReferenceFailure } from "./failures/map-reference-failures.js";
+export { createHarnessState, addFailure, recordNodeResult, updateMetrics, captureSnapshot } from "./state/snapshots.js";
+export { parsePromptOrSkill } from "./synthesis/skill-parser.js";
+export { buildTaskGraph } from "./synthesis/graph-builder.js";
+export { analyzeRisks } from "./synthesis/risk-analyzer.js";
+export { synthesizePolicy } from "./synthesis/policy-builder.js";
+export { synthesizeHarness } from "./synthesis/harness-builder.js";
+export { createInitialVersion, createNextVersion, createLineageEntry } from "./versioning/history.js";
+export { prepareInitialAdaptiveInput, unwrapAdaptiveInput, prepareRuntimeReplan, MAX_ADAPTIVE_VERSIONS } from "./replanner/runtime.js";
+export type { MetaHarnessConfig, MetaHarnessResult, MetaHarness } from "./metaharness/types.js";
+export { DefaultMetaHarness } from "./metaharness/engine.js";
+export { predictFailuresFromEnvironment } from "./metaharness/predictor.js";
+export { discoverEnvironment } from "./environment/discovery.js";
+export { analyzeEnvironment } from "./environment/analyzer.js";
+export type { EnvironmentModel, EnvironmentAnalysis, ToolCapability, Constraint } from "./environment/types.js";
+export { classifyFailure } from "./failures/ontology.js";
+export { suggestRecovery } from "./failures/recovery.js";
+export type { FailureSignature, FailureClass } from "./failures/ontology.js";
+export type { RecoveryPlan } from "./failures/recovery.js";
+export { FileMemoryStore } from "./memory/store.js";
+export { adviseFromMemory } from "./memory/advisor.js";
+export { extractPatternsFromTrace } from "./memory/extractor.js";
+export type { HarnessMemory, MemoryStore, MemoryAdvice } from "./memory/types.js";
+export { analyzeCompiledWorkflow, applyCompilerSuggestions } from "./compiler/feedback.js";
+export type { CostEstimate, CompilerAnalysis, CompilerSuggestion } from "./compiler/feedback.js";
+export type { HarnessMutation, MutationType, MutationTrigger, MutationPolicy, MutationResult, SpecDiff } from "./mutation/types.js";
+export { mutateHarness } from "./mutation/engine.js";
+export { deriveMutationsFromTrace, deriveMutationsFromFailure } from "./mutation/derive.js";
+export { diffSpecs } from "./mutation/diff.js";
+export { chainHarnesses } from "./composition/chain.js";
+export { parallelHarnesses } from "./composition/parallel.js";
+export { conditionalHarness } from "./composition/conditional.js";
+export type { HarnessStage, CompositionResult, HarnessComposer } from "./composition/types.js";
+export { DefaultCapabilityRegistry } from "./capabilities/registry.js";
+export type { Capability, CapabilityRegistry } from "./capabilities/types.js";
+export { default } from "./pi/extension.js";

package/src/memory/advisor.ts

@@ -0,0 +1,132 @@
+import type { MemoryStore, MemoryQuery, MemoryAdvice, TaskSignatureOptions } from "./types.js";
+import type { HarnessSpec } from "../spec/types.js";
+
+export async function adviseFromMemory(
+  taskSignature: string,
+  memoryStore: MemoryStore,
+  options?: TaskSignatureOptions | HarnessSpec,
+  currentSpec?: HarnessSpec,
+): Promise<MemoryAdvice> {
+  let queryOptions: TaskSignatureOptions | undefined;
+  let spec: HarnessSpec | undefined;
+
+  if (options && isHarnessSpec(options)) {
+    spec = options;
+  } else {
+    queryOptions = options;
+  }
+
+  if (currentSpec) {
+    spec = currentSpec;
+  }
+
+  const query: MemoryQuery = {
+    taskSignature: queryOptions?.taskSignature,
+    minEffectiveness: queryOptions?.minEffectiveness,
+  };
+
+  const memories = await memoryStore.searchMemories(query);
+
+  if (memories.length === 0) {
+    return {
+      suggestions: [],
+      warnings: [],
+      sourceTaskIds: [],
+      aggregateEffectiveness: 0,
+    };
+  }
+
+  const suggestions: string[] = [];
+  const warnings: string[] = [];
+  const sourceTaskIds: string[] = [];
+  let totalEffectiveness = 0;
+
+  const existingNodeIds = spec ? new Set(spec.graph.nodes.map((n) => n.id)) : new Set<string>();
+
+  for (const memory of memories) {
+    sourceTaskIds.push(memory.taskId);
+    totalEffectiveness += memory.effectivenessScore;
+
+    for (const pattern of memory.successfulPatterns) {
+      const patternNodes = extractNodeIdsFromPattern(pattern);
+      const hasAllNodes = patternNodes.every((id) => existingNodeIds.has(id));
+
+      if (hasAllNodes && patternNodes.length > 0) {
+        suggestions.push(`Pattern "${pattern}" already exists in current spec`);
+      } else {
+        const effectivenessPct = Math.round(memory.effectivenessScore * 100);
+        suggestions.push(
+          `Previously, "${pattern}" improved success rate (${effectivenessPct}% effectiveness in task ${memory.taskId})`,
+        );
+      }
+    }
+
+    for (const pattern of memory.failedPatterns) {
+      warnings.push(
+        `Pattern "${pattern}" failed in task ${memory.taskId} (effectiveness: ${Math.round(memory.effectivenessScore * 100)}%)`,
+      );
+    }
+
+    for (const record of memory.mutationHistory) {
+      if (record.outcome === "improved") {
+        suggestions.push(
+          `Mutation "${record.mutation}" previously improved outcomes (triggered by: ${record.triggeredBy})`,
+        );
+      } else if (record.outcome === "worse") {
+        warnings.push(
+          `Mutation "${record.mutation}" previously worsened outcomes (triggered by: ${record.triggeredBy}) - avoid this approach`,
+        );
+      }
+    }
+  }
+
+  const aggregateEffectiveness = memories.length > 0
+    ? totalEffectiveness / memories.length
+    : 0;
+
+  const uniqueSuggestions = [...new Set(suggestions)];
+  const uniqueWarnings = [...new Set(warnings)];
+
+  uniqueSuggestions.sort((a, b) => {
+    const aHasAlready = a.includes("already");
+    const bHasAlready = b.includes("already");
+    if (aHasAlready && !bHasAlready) return 1;
+    if (!aHasAlready && bHasAlready) return -1;
+    return 0;
+  });
+
+  return {
+    suggestions: uniqueSuggestions,
+    warnings: uniqueWarnings,
+    sourceTaskIds,
+    aggregateEffectiveness,
+  };
+}
+
+function isHarnessSpec(value: unknown): value is HarnessSpec {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    "name" in value &&
+    "graph" in value &&
+    typeof (value as Record<string, unknown>).graph === "object" &&
+    "nodes" in ((value as Record<string, unknown>).graph as Record<string, unknown>)
+  );
+}
+
+function extractNodeIdsFromPattern(pattern: string): string[] {
+  const nodePattern = /([a-zA-Z0-9_-]+)-before-([a-zA-Z0-9_-]+)/;
+  const match = pattern.match(nodePattern);
+
+  if (match) {
+    return [match[1], match[2]];
+  }
+
+  const singleNodePattern = /^([a-zA-Z0-9_-]+)-/;
+  const singleMatch = pattern.match(singleNodePattern);
+  if (singleMatch) {
+    return [singleMatch[1]];
+  }
+
+  return [];
+}

package/src/memory/extractor.ts

@@ -0,0 +1,166 @@
+import type { HarnessExecutionTrace } from "../versioning/types.js";
+import type { HarnessSpec } from "../spec/types.js";
+import type { ExecutionTraceEntry } from "../compiler/runtime-helpers.js";
+
+interface NodeSequence {
+  nodeId: string;
+  phases: ExecutionTraceEntry["phase"][];
+}
+
+export function extractPatternsFromTrace(
+  trace: HarnessExecutionTrace,
+  spec: HarnessSpec,
+): { successful: string[]; failed: string[] } {
+  if (trace.entries.length === 0) {
+    return { successful: [], failed: [] };
+  }
+
+  const successful: string[] = [];
+  const failed: string[] = [];
+
+  const nodeSequences = buildNodeSequences(trace.entries);
+  const nodeOrder = extractNodeOrder(trace.entries);
+
+  for (const sequence of nodeSequences) {
+    const hasSuccess = sequence.phases.includes("success");
+    const hasFailure = sequence.phases.includes("failure");
+    const hasRetry = sequence.phases.includes("retry");
+    const hasVerificationFail = sequence.phases.includes("verification-fail");
+
+    if (hasSuccess && !hasFailure) {
+      successful.push(`${sequence.nodeId}-succeeds`);
+    }
+
+    if (hasFailure) {
+      failed.push(`${sequence.nodeId}-fails`);
+    }
+
+    if (hasRetry && hasSuccess) {
+      successful.push(`${sequence.nodeId}-retry-succeeds`);
+    }
+
+    if (hasVerificationFail) {
+      failed.push(`${sequence.nodeId}-verification-fails`);
+    }
+  }
+
+  const orderingPatterns = extractOrderingPatterns(nodeOrder, trace.entries);
+  successful.push(...orderingPatterns.successful);
+  failed.push(...orderingPatterns.failed);
+
+  const specOrderingPatterns = extractSpecOrderingPatterns(nodeOrder, spec, trace.entries);
+  successful.push(...specOrderingPatterns);
+
+  return {
+    successful: deduplicate(successful),
+    failed: deduplicate(failed),
+  };
+}
+
+function buildNodeSequences(entries: ExecutionTraceEntry[]): NodeSequence[] {
+  const sequences = new Map<string, NodeSequence>();
+
+  for (const entry of entries) {
+    if (!sequences.has(entry.nodeId)) {
+      sequences.set(entry.nodeId, { nodeId: entry.nodeId, phases: [] });
+    }
+    sequences.get(entry.nodeId)!.phases.push(entry.phase);
+  }
+
+  return Array.from(sequences.values());
+}
+
+function extractNodeOrder(entries: ExecutionTraceEntry[]): string[] {
+  const seen = new Set<string>();
+  const order: string[] = [];
+
+  for (const entry of entries) {
+    if (!seen.has(entry.nodeId)) {
+      seen.add(entry.nodeId);
+      order.push(entry.nodeId);
+    }
+  }
+
+  return order;
+}
+
+function extractOrderingPatterns(
+  nodeOrder: string[],
+  entries: ExecutionTraceEntry[],
+): { successful: string[]; failed: string[] } {
+  const successful: string[] = [];
+  const failed: string[] = [];
+
+  const nodeOutcomes = new Map<string, { success: boolean; failure: boolean }>();
+
+  for (const entry of entries) {
+    if (!nodeOutcomes.has(entry.nodeId)) {
+      nodeOutcomes.set(entry.nodeId, { success: false, failure: false });
+    }
+    const outcome = nodeOutcomes.get(entry.nodeId)!;
+    if (entry.phase === "success") outcome.success = true;
+    if (entry.phase === "failure") outcome.failure = true;
+  }
+
+  for (let i = 0; i < nodeOrder.length - 1; i++) {
+    const current = nodeOrder[i];
+    const next = nodeOrder[i + 1];
+    const currentOutcome = nodeOutcomes.get(current);
+    const nextOutcome = nodeOutcomes.get(next);
+
+    if (!currentOutcome || !nextOutcome) continue;
+
+    if (currentOutcome.success && nextOutcome.success) {
+      successful.push(`${current}-before-${next}-succeeds`);
+    }
+
+    if (currentOutcome.success && nextOutcome.failure) {
+      failed.push(`${current}-before-${next}-fails`);
+    }
+
+    if (currentOutcome.failure && nextOutcome.success) {
+      successful.push(`${current}-fails-but-${next}-succeeds`);
+    }
+  }
+
+  return { successful, failed };
+}
+
+function extractSpecOrderingPatterns(
+  nodeOrder: string[],
+  spec: HarnessSpec,
+  entries: ExecutionTraceEntry[],
+): string[] {
+  const patterns: string[] = [];
+
+  const hasTerminalPhases = entries.some(
+    (e) => e.phase === "success" || e.phase === "failure" || e.phase === "verification-fail",
+  );
+
+  if (!hasTerminalPhases) {
+    return patterns;
+  }
+
+  for (const edge of spec.graph.edges) {
+    const fromIdx = nodeOrder.indexOf(edge.from);
+    const toIdx = nodeOrder.indexOf(edge.to);
+
+    if (fromIdx !== -1 && toIdx !== -1 && fromIdx < toIdx) {
+      const fromNode = spec.graph.nodes.find((n) => n.id === edge.from);
+      const toNode = spec.graph.nodes.find((n) => n.id === edge.to);
+
+      if (fromNode && toNode) {
+        const fromKind = fromNode.kind;
+        if (fromKind === "tool" || fromKind === "condition") {
+          patterns.push(`${edge.from}-before-${edge.to}`);
+        }
+      }
+    }
+  }
+
+  return patterns;
+}
+
+function deduplicate(arr: string[]): string[] {
+  return [...new Set(arr)];
+}

package/src/memory/store.ts

@@ -0,0 +1,107 @@
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { HarnessMemory, MemoryStore, MemoryUpdate, MemoryQuery } from "./types.js";
+
+export class FileMemoryStore implements MemoryStore {
+  private readonly memoriesDir: string;
+
+  constructor(private readonly storeDir: string) {
+    this.memoriesDir = join(storeDir, "memories");
+  }
+
+  async saveMemory(memory: HarnessMemory): Promise<void> {
+    await mkdir(this.memoriesDir, { recursive: true });
+    const data = structuredClone(memory);
+    const filePath = join(this.memoriesDir, `${memory.taskId}.json`);
+    const tmpPath = `${filePath}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    await rename(tmpPath, filePath);
+  }
+
+  async getMemory(taskId: string): Promise<HarnessMemory | null> {
+    try {
+      const filePath = join(this.memoriesDir, `${taskId}.json`);
+      const raw = await readFile(filePath, "utf-8");
+      return JSON.parse(raw) as HarnessMemory;
+    } catch (err: unknown) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") return null;
+      throw err;
+    }
+  }
+
+  async updateMemory(taskId: string, update: MemoryUpdate): Promise<HarnessMemory> {
+    const existing = await this.getMemory(taskId);
+    if (!existing) {
+      throw new Error(`Memory not found for task: ${taskId}`);
+    }
+
+    const updated: HarnessMemory = structuredClone(existing);
+
+    if (update.successfulPattern) {
+      if (!updated.successfulPatterns.includes(update.successfulPattern)) {
+        updated.successfulPatterns.push(update.successfulPattern);
+      }
+    }
+
+    if (update.failedPattern) {
+      if (!updated.failedPatterns.includes(update.failedPattern)) {
+        updated.failedPatterns.push(update.failedPattern);
+      }
+    }
+
+    if (update.mutation) {
+      updated.mutationHistory.push(structuredClone(update.mutation));
+    }
+
+    if (update.effectivenessDelta !== undefined) {
+      updated.effectivenessScore = Math.max(
+        0,
+        Math.min(1, updated.effectivenessScore + update.effectivenessDelta),
+      );
+    }
+
+    updated.lastUpdated = Date.now();
+
+    await this.saveMemory(updated);
+    return updated;
+  }
+
+  async searchMemories(query: MemoryQuery): Promise<HarnessMemory[]> {
+    let memories = await this.loadAllMemories();
+
+    if (query.taskSignature) {
+      memories = memories.filter(
+        (m) => m.taskEmbedding && m.taskEmbedding.includes(query.taskSignature!),
+      );
+    }
+
+    if (query.minEffectiveness !== undefined) {
+      memories = memories.filter(
+        (m) => m.effectivenessScore >= query.minEffectiveness!,
+      );
+    }
+
+    if (query.limit !== undefined) {
+      memories = memories.slice(0, query.limit);
+    }
+
+    return memories;
+  }
+
+  private async loadAllMemories(): Promise<HarnessMemory[]> {
+    try {
+      const files = await readdir(this.memoriesDir);
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      const memories = await Promise.all(
+        jsonFiles.map(async (file) => {
+          const raw = await readFile(join(this.memoriesDir, file), "utf-8");
+          return JSON.parse(raw) as HarnessMemory;
+        }),
+      );
+      return memories.sort((a, b) => b.effectivenessScore - a.effectivenessScore);
+    } catch {
+      return [];
+    }
+  }
+}