@mhingston5/lasso 0.1.0

package/src/memory/types.ts

@@ -0,0 +1,53 @@
+import type { HarnessExecutionTrace } from "../versioning/types.js";
+import type { HarnessSpec } from "../spec/types.js";
+
+export interface HarnessMemory {
+  taskId: string;
+  taskEmbedding?: string;
+  successfulPatterns: string[];
+  failedPatterns: string[];
+  mutationHistory: MutationRecord[];
+  effectivenessScore: number;
+  lastUpdated: number;
+}
+
+export interface MutationRecord {
+  mutation: string;
+  triggeredBy: string;
+  timestamp: number;
+  outcome: "improved" | "no-change" | "worse";
+}
+
+export interface MemoryStore {
+  getMemory(taskId: string): Promise<HarnessMemory | null>;
+  saveMemory(memory: HarnessMemory): Promise<void>;
+  updateMemory(taskId: string, update: MemoryUpdate): Promise<HarnessMemory>;
+  searchMemories(query: MemoryQuery): Promise<HarnessMemory[]>;
+}
+
+export interface MemoryUpdate {
+  successfulPattern?: string;
+  failedPattern?: string;
+  mutation?: MutationRecord;
+  effectivenessDelta?: number;
+}
+
+export interface MemoryQuery {
+  taskSignature?: string;
+  minEffectiveness?: number;
+  limit?: number;
+}
+
+export interface MemoryAdvice {
+  suggestions: string[];
+  warnings: string[];
+  sourceTaskIds: string[];
+  aggregateEffectiveness: number;
+}
+
+export interface TaskSignatureOptions {
+  taskSignature?: string;
+  minEffectiveness?: number;
+}
+
+export { HarnessExecutionTrace, HarnessSpec };

package/src/metaharness/engine.ts

@@ -0,0 +1,256 @@
+import type { HarnessSpec } from "../spec/types.js";
+import type { EnvironmentModel, EnvironmentAnalysis } from "../environment/types.js";
+import type { FailureSignature } from "../failures/ontology.js";
+import type { MemoryAdvice, MemoryStore } from "../memory/types.js";
+import type { CapabilityRegistry } from "../capabilities/types.js";
+import type { MutationPolicy, HarnessMutation } from "../mutation/types.js";
+import type { MetaHarnessConfig, MetaHarnessResult, MetaHarness } from "./types.js";
+import type { CompilerAnalysis } from "../compiler/feedback.js";
+import type { HarnessStage, CompositionResult } from "../composition/types.js";
+import { discoverEnvironment } from "../environment/discovery.js";
+import { analyzeEnvironment } from "../environment/analyzer.js";
+import { adviseFromMemory } from "../memory/advisor.js";
+import { planWorkflowRequest } from "../planner/synthesize.js";
+import { parsePromptOrSkill } from "../synthesis/skill-parser.js";
+import { buildTaskGraph } from "../synthesis/graph-builder.js";
+import { analyzeRisks } from "../synthesis/risk-analyzer.js";
+import { synthesizeHarness } from "../synthesis/harness-builder.js";
+import { compileHarnessSpec } from "../compiler/compile.js";
+import { analyzeCompiledWorkflow } from "../compiler/feedback.js";
+import { predictFailuresFromEnvironment } from "./predictor.js";
+import { generateFailureModes } from "../failures/generator.js";
+import { deriveMutationsFromFailure } from "../mutation/derive.js";
+import { mutateHarness } from "../mutation/engine.js";
+import { chainHarnesses } from "../composition/chain.js";
+import { parallelHarnesses } from "../composition/parallel.js";
+import { conditionalHarness } from "../composition/conditional.js";
+
+export class DefaultMetaHarness implements MetaHarness {
+  constructor(private config: MetaHarnessConfig) {}
+
+  async discoverEnvironment(repoPath?: string): Promise<EnvironmentModel> {
+    return discoverEnvironment(repoPath);
+  }
+
+  async predictFailures(
+    spec: HarnessSpec,
+    env: EnvironmentModel,
+  ): Promise<FailureSignature[]> {
+    return predictFailuresFromEnvironment(spec, env);
+  }
+
+  synthesizePolicies(
+    spec: HarnessSpec,
+    failures: FailureSignature[],
+  ): HarnessSpec {
+    if (failures.length === 0) {
+      return spec;
+    }
+
+    const allMutations = [];
+    for (const failure of failures) {
+      const nodeId = extractNodeIdFromFailure(failure) ?? spec.graph.entryNodeId;
+      const ctx = { nodeId };
+      const mutations = deriveMutationsFromFailure(failure, spec, ctx);
+      allMutations.push(...mutations);
+    }
+
+    if (allMutations.length === 0) {
+      return spec;
+    }
+
+    const limitedMutations = this.config.mutationPolicy
+      ? enforceMutationPolicy(allMutations, this.config.mutationPolicy)
+      : allMutations;
+
+    const result = mutateHarness(spec, limitedMutations, this.config.mutationPolicy);
+    return result.spec;
+  }
+
+  async generateHarness(
+    intent: string,
+    config?: MetaHarnessConfig,
+  ): Promise<MetaHarnessResult> {
+    const effectiveConfig = config ?? this.config;
+
+    // 1. Discover environment (use cached if provided)
+    let env: EnvironmentModel;
+    if (effectiveConfig.environmentModel) {
+      env = effectiveConfig.environmentModel;
+    } else {
+      env = await this.discoverEnvironment();
+    }
+
+    const envAnalysis = analyzeEnvironment(env);
+
+    // 2. Query memory for advice
+    let memoryAdvice: MemoryAdvice | undefined;
+    if (effectiveConfig.memoryStore) {
+      memoryAdvice = await adviseFromMemory(intent, effectiveConfig.memoryStore);
+      if (memoryAdvice.suggestions.length === 0 && memoryAdvice.warnings.length === 0) {
+        memoryAdvice = undefined;
+      }
+    }
+
+    // 3. Plan workflow from intent
+    const plannerResult = planWorkflowRequest(
+      intent,
+      effectiveConfig.capabilityRegistry,
+      env,
+    );
+
+    let spec: HarnessSpec;
+    if (plannerResult.status === "draft_request") {
+      const parsed = parsePromptOrSkill(intent);
+      const taskGraph = buildTaskGraph(
+        parsed.success ? parsed.intent : {
+          family: "custom",
+          goal: intent,
+          inputs: {},
+          requiredTools: [],
+          humanCheckpoints: [],
+          verificationTargets: [],
+        },
+        effectiveConfig.capabilityRegistry,
+        env,
+      );
+      const risks = analyzeRisks(taskGraph, effectiveConfig.capabilityRegistry);
+      spec = synthesizeHarness(taskGraph, risks);
+    } else {
+      spec = makeFallbackSpec(intent);
+    }
+
+    // 4. Predict failures
+    const predictedFailures = await this.predictFailures(spec, env);
+
+    // 4b. Generate failure modes from task description
+    const generatedFailureModes = generateFailureModes(intent, env, spec);
+
+    // 5. Synthesize policies (mutate spec)
+    spec = this.synthesizePolicies(spec, predictedFailures);
+
+    // 6. Compile, analyze, and apply feedback loop
+    let optimizations: string[] = [];
+    let compilerOptimizations: string[] = [];
+    let compilerAnalysis: CompilerAnalysis | undefined;
+    const appliedMutations: HarnessMutation[] = [];
+
+    try {
+      let compiled = compileHarnessSpec(spec);
+      if (compiled.optimizations) {
+        optimizations = compiled.optimizations;
+      }
+
+      // Analyze the compiled workflow
+      compilerAnalysis = analyzeCompiledWorkflow(compiled);
+
+      // Use mutations directly from the feedback engine
+      const feedbackMutations = compilerAnalysis.mutations.filter(
+        m => m.trigger === "retry_exhausted" || m.trigger === "verification_failed" || m.trigger === "cost_high"
+      );
+
+      if (feedbackMutations.length > 0) {
+        const limitedMutations = this.config.mutationPolicy
+          ? enforceMutationPolicy(feedbackMutations, this.config.mutationPolicy)
+          : feedbackMutations;
+
+        const mutationResult = mutateHarness(spec, limitedMutations);
+        spec = mutationResult.spec;
+        appliedMutations.push(...limitedMutations);
+        compilerOptimizations = limitedMutations.map(m => m.description ?? m.type);
+
+        // Recompile with the modified spec
+        compiled = compileHarnessSpec(spec);
+        if (compiled.optimizations) {
+          optimizations = compiled.optimizations;
+        }
+
+        // Re-analyze after recompilation
+        compilerAnalysis = analyzeCompiledWorkflow(compiled);
+      }
+    } catch {
+      // If compilation fails, still return the spec without optimizations
+    }
+
+    // 7. Calculate readiness score
+    const readinessScore = calculateReadinessScore(envAnalysis, predictedFailures);
+
+    return {
+      spec,
+      environmentAnalysis: envAnalysis,
+      memoryAdvice,
+      predictedFailures,
+      generatedFailureModes,
+      optimizations,
+      readinessScore,
+      compilerAnalysis,
+      compilerOptimizations,
+      appliedMutations,
+    };
+  }
+
+  composeHarnesses(stages: HarnessStage[]): CompositionResult {
+    return chainHarnesses(stages);
+  }
+
+  composeParallel(harnesses: HarnessSpec[]): CompositionResult {
+    return parallelHarnesses(harnesses);
+  }
+
+  composeConditional(condition: string, trueHarness: HarnessSpec, falseHarness?: HarnessSpec): CompositionResult {
+    return conditionalHarness(condition, trueHarness, falseHarness);
+  }
+}
+
+function extractNodeIdFromFailure(failure: FailureSignature): string | undefined {
+  for (const evidence of failure.evidence) {
+    const match = evidence.match(/^node:\s*(.+)$/);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+  return undefined;
+}
+
+function enforceMutationPolicy(
+  mutations: ReturnType<typeof deriveMutationsFromFailure>,
+  policy: MutationPolicy,
+): ReturnType<typeof deriveMutationsFromFailure> {
+  const allowed = new Set(policy.allowedMutations);
+  const filtered = mutations.filter(m => allowed.has(m.type));
+  return filtered.slice(0, policy.maxMutations);
+}
+
+function makeFallbackSpec(intent: string): HarnessSpec {
+  const safeName = intent.slice(0, 50).replace(/[^a-zA-Z0-9\s-]/g, "").trim().replace(/\s+/g, "-").toLowerCase() || "meta-harness";
+  return {
+    name: safeName,
+    graph: {
+      entryNodeId: "intent-node",
+      nodes: [
+        {
+          id: "intent-node",
+          label: intent.slice(0, 100),
+          kind: "tool",
+          tool: "echo",
+          args: [intent],
+        },
+      ],
+      edges: [],
+    },
+  };
+}
+
+function calculateReadinessScore(
+  envAnalysis: EnvironmentAnalysis,
+  predictedFailures: FailureSignature[],
+): number {
+  let score = envAnalysis.readinessScore;
+
+  for (const failure of predictedFailures) {
+    const penalty = Math.round(failure.confidence * 15);
+    score = Math.max(0, score - penalty);
+  }
+
+  return Math.min(100, Math.max(0, score));
+}

package/src/metaharness/predictor.ts

@@ -0,0 +1,168 @@
+import type { HarnessSpec, TaskNode } from "../spec/types.js";
+import type { EnvironmentModel } from "../environment/types.js";
+import type { FailureSignature } from "../failures/ontology.js";
+
+const DISK_CRITICAL_THRESHOLD = 90;
+
+export function predictFailuresFromEnvironment(
+  spec: HarnessSpec,
+  env: EnvironmentModel,
+): FailureSignature[] {
+  const failures: FailureSignature[] = [];
+
+  for (const node of spec.graph.nodes) {
+    const nodeFailures = predictNodeFailures(node, env);
+    failures.push(...nodeFailures);
+  }
+
+  const constraintFailures = predictConstraintFailures(env);
+  failures.push(...constraintFailures);
+
+  const authFailures = predictAuthFailures(spec, env);
+  failures.push(...authFailures);
+
+  const resourceFailures = predictResourceFailures(env);
+  failures.push(...resourceFailures);
+
+  return failures;
+}
+
+function predictNodeFailures(
+  node: TaskNode,
+  env: EnvironmentModel,
+): FailureSignature[] {
+  if (node.kind !== "tool") {
+    return [];
+  }
+
+  const toolName = node.tool;
+  const availableTool = env.tools.find(t => t.name === toolName);
+
+  if (!availableTool || !availableTool.available) {
+    return [
+      {
+        class: "tool",
+        confidence: 0.85,
+        evidence: [
+          `node: ${node.id}`,
+          `tool "${toolName}" is not available in environment`,
+        ],
+        suggestedRecovery: [
+          `Install "${toolName}" and ensure it is in PATH`,
+          "Verify tool version compatibility",
+        ],
+        retryable: false,
+        requiresHumanIntervention: true,
+      },
+    ];
+  }
+
+  return [];
+}
+
+function predictConstraintFailures(env: EnvironmentModel): FailureSignature[] {
+  const failures: FailureSignature[] = [];
+
+  for (const constraint of env.constraints) {
+    if (constraint.severity === "high") {
+      failures.push({
+        class: constraint.type === "auth" ? "auth" : "unknown",
+        confidence: 0.8,
+        evidence: [
+          `constraint: ${constraint.description}`,
+          `severity: ${constraint.severity}`,
+        ],
+        suggestedRecovery: [
+          `Address constraint: ${constraint.description}`,
+          "Review environment configuration",
+        ],
+        retryable: false,
+        requiresHumanIntervention: constraint.type === "auth" || constraint.type === "permission",
+      });
+    }
+  }
+
+  return failures;
+}
+
+function predictAuthFailures(
+  spec: HarnessSpec,
+  env: EnvironmentModel,
+): FailureSignature[] {
+  const failures: FailureSignature[] = [];
+
+  for (const auth of env.authState) {
+    if (!auth.authenticated) {
+      failures.push({
+        class: "auth",
+        confidence: 0.9,
+        evidence: [
+          `system "${auth.system}" is not authenticated`,
+        ],
+        suggestedRecovery: [
+          `Authenticate with "${auth.system}" before running harness`,
+          "Check token expiry and renew if necessary",
+          "Verify API keys or secrets are correctly configured",
+        ],
+        retryable: false,
+        requiresHumanIntervention: true,
+      });
+    }
+  }
+
+  return failures;
+}
+
+function predictResourceFailures(env: EnvironmentModel): FailureSignature[] {
+  const failures: FailureSignature[] = [];
+
+  for (const resource of env.resources) {
+    if (!resource.available) {
+      failures.push({
+        class: "resource",
+        confidence: 0.9,
+        evidence: [
+          `resource "${resource.name}" is not available`,
+          `type: ${resource.type}`,
+        ],
+        suggestedRecovery: [
+          `Free up or provision "${resource.name}" resource`,
+          "Check available disk space and clean up if necessary",
+        ],
+        retryable: true,
+        requiresHumanIntervention: false,
+      });
+      continue;
+    }
+
+    if (resource.type === "disk" && resource.usage) {
+      const usagePct = parseUsagePercentage(resource.usage);
+      if (usagePct >= DISK_CRITICAL_THRESHOLD) {
+        failures.push({
+          class: "resource",
+          confidence: 0.85,
+          evidence: [
+            `disk usage is critical: ${resource.usage}`,
+            `threshold: ${DISK_CRITICAL_THRESHOLD}%`,
+          ],
+          suggestedRecovery: [
+            "Clean up disk space before running harness",
+            "Remove temporary files and unused artifacts",
+          ],
+          retryable: true,
+          requiresHumanIntervention: false,
+        });
+      }
+    }
+  }
+
+  return failures;
+}
+
+function parseUsagePercentage(usage: string): number {
+  const match = usage.match(/(\d+)%/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return 0;
+}

package/src/metaharness/types.ts

@@ -0,0 +1,40 @@
+import type { HarnessSpec } from "../spec/types.js";
+import type { EnvironmentModel, EnvironmentAnalysis } from "../environment/types.js";
+import type { FailureSignature } from "../failures/ontology.js";
+import type { FailureModeGeneration } from "../failures/generator.js";
+import type { MemoryAdvice, MemoryStore } from "../memory/types.js";
+import type { CapabilityRegistry } from "../capabilities/types.js";
+import type { MutationPolicy, HarnessMutation } from "../mutation/types.js";
+import type { CompilerAnalysis, CompilerSuggestion } from "../compiler/feedback.js";
+import type { HarnessStage, CompositionResult } from "../composition/types.js";
+
+export interface MetaHarnessConfig {
+  environmentModel?: EnvironmentModel;
+  memoryStore?: MemoryStore;
+  capabilityRegistry?: CapabilityRegistry;
+  maxVersions?: number;
+  mutationPolicy?: MutationPolicy;
+}
+
+export interface MetaHarnessResult {
+  spec: HarnessSpec;
+  environmentAnalysis?: EnvironmentAnalysis;
+  memoryAdvice?: MemoryAdvice;
+  predictedFailures: FailureSignature[];
+  generatedFailureModes?: FailureModeGeneration;
+  optimizations: string[];
+  readinessScore: number;
+  compilerAnalysis?: CompilerAnalysis;
+  compilerOptimizations: string[];
+  appliedMutations: HarnessMutation[];
+}
+
+export interface MetaHarness {
+  discoverEnvironment(repoPath?: string): Promise<EnvironmentModel>;
+  predictFailures(spec: HarnessSpec, env: EnvironmentModel): Promise<FailureSignature[]>;
+  synthesizePolicies(spec: HarnessSpec, failures: FailureSignature[]): HarnessSpec;
+  generateHarness(intent: string, config?: MetaHarnessConfig): Promise<MetaHarnessResult>;
+  composeHarnesses(stages: HarnessStage[]): CompositionResult;
+  composeParallel(harnesses: HarnessSpec[]): CompositionResult;
+  composeConditional(condition: string, trueHarness: HarnessSpec, falseHarness?: HarnessSpec): CompositionResult;
+}