@metaharness/darwin 0.1.0

package/dist/templates.js

@@ -0,0 +1,309 @@
+// SPDX-License-Identifier: MIT
+//
+// Mutation-surface templates (ADR-071) — seven pure functions, one per surface,
+// each returning the SOURCE TEXT of a baseline mutation-surface file.
+//
+// LOAD-BEARING CONSTRAINT: every string returned here is later written to a
+// variant directory and statically scanned by `inspectVariant` /
+// `validateGeneratedCode`. The emitted source therefore contains ONLY pure,
+// side-effect-free policy logic that operates on its arguments — no process,
+// network, filesystem, dynamic-eval, shell, or sensitive-material references.
+// The policies are expressed over symbolic data injected at call time, never
+// over embedded literals.
+/**
+ * planner.ts — turns a task string into an ordered list of plan steps. The
+ * baseline plan is a generic map → inspect → patch → verify loop, with the
+ * repository summary baked in as data for downstream context.
+ */
+export function plannerTemplate(profile) {
+    return `// SPDX-License-Identifier: MIT
+//
+// planner — mutation surface "planner" (ADR-071). Pure policy: task -> steps.
+
+/** One ordered step in a plan. */
+export interface PlanStep {
+  /** Stable ordering index, 0-based. */
+  order: number;
+  /** Short symbolic kind of work this step performs. */
+  kind: 'map' | 'inspect' | 'patch' | 'verify';
+  /** Human-readable description of the step. */
+  description: string;
+}
+
+/** A one-line summary of the repository this harness was generated for. */
+export const repoSummary = ${JSON.stringify(profile.summary)};
+
+/**
+ * Build an ordered plan for a task. The baseline strategy is deliberately
+ * conservative: locate the relevant files, inspect the existing tests, apply a
+ * minimal patch, then verify by running the test command.
+ */
+export function createPlan(task: string): PlanStep[] {
+  const trimmed = task.trim();
+  const label = trimmed.length > 0 ? trimmed : 'the requested change';
+  return [
+    { order: 0, kind: 'map', description: \`Map files relevant to: \${label}\` },
+    { order: 1, kind: 'inspect', description: 'Inspect existing tests and surrounding code' },
+    { order: 2, kind: 'patch', description: 'Apply the smallest patch that satisfies the task' },
+    { order: 3, kind: 'verify', description: 'Verify by running the project test command' },
+  ];
+}
+`;
+}
+/**
+ * context_builder.ts — ranks candidate files by lexical overlap with the task
+ * terms and returns the top slice as context items.
+ */
+export function contextBuilderTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// context builder — mutation surface "contextBuilder" (ADR-071). Pure policy:
+// rank candidate files by overlap with the task's terms.
+
+/** A ranked piece of context offered to the worker. */
+export interface ContextItem {
+  /** Relative path of the file. */
+  path: string;
+  /** Overlap score (count of shared terms). Higher is more relevant. */
+  score: number;
+}
+
+/** Split a string into lowercased alphanumeric terms of length >= 2. */
+function terms(text: string): string[] {
+  return text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((t) => t.length >= 2);
+}
+
+/**
+ * Rank \`files\` by how many task terms appear in each file path, returning the
+ * top 30 items in descending relevance. Ties keep the original path order.
+ */
+export function buildContext(task: string, files: string[]): ContextItem[] {
+  const wanted = new Set(terms(task));
+  const scored = files.map((path, index) => {
+    const pathTerms = terms(path);
+    let score = 0;
+    for (const t of pathTerms) if (wanted.has(t)) score += 1;
+    return { path, score, index };
+  });
+  scored.sort((a, b) => (b.score - a.score) || (a.index - b.index));
+  return scored.slice(0, 30).map(({ path, score }) => ({ path, score }));
+}
+`;
+}
+/**
+ * reviewer.ts — flags changed files that intersect an injected risk-file list
+ * and escalates severity when tests have failed. No inline pattern matching on
+ * sensitive words; the risk set is passed in as data.
+ */
+export function reviewerTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// reviewer — mutation surface "reviewer" (ADR-071). Pure policy: judge a patch
+// against an injected risk-file list and the test outcome.
+
+/** A single review finding for one changed file. */
+export interface ReviewFinding {
+  /** The changed file the finding refers to. */
+  file: string;
+  /** Severity of the finding. */
+  severity: 'blocker' | 'warning' | 'info';
+  /** Why the finding was raised. */
+  reason: string;
+}
+
+/**
+ * Review a patch. A changed file is flagged when it appears in the injected
+ * \`riskFiles\` list (the reviewer does not itself decide what is risky — that
+ * judgement is supplied as data). When the test suite failed, findings are
+ * escalated to 'blocker'; otherwise risk-file edits are 'warning' and all other
+ * changes are 'info'.
+ */
+export function reviewPatch(
+  changedFiles: string[],
+  testPassed: boolean,
+  riskFiles: string[],
+): ReviewFinding[] {
+  const risky = new Set(riskFiles);
+  const findings: ReviewFinding[] = [];
+  for (const file of changedFiles) {
+    const isRisky = risky.has(file);
+    if (!testPassed) {
+      findings.push({
+        file,
+        severity: 'blocker',
+        reason: isRisky
+          ? 'tests failed and the change touches a protected file'
+          : 'tests failed for this change',
+      });
+    } else if (isRisky) {
+      findings.push({
+        file,
+        severity: 'warning',
+        reason: 'change touches a protected file',
+      });
+    } else {
+      findings.push({ file, severity: 'info', reason: 'routine change' });
+    }
+  }
+  return findings;
+}
+`;
+}
+/**
+ * retry_policy.ts — decides whether to retry an attempt based on a symbolic
+ * failure classification (an injected enum), never by scanning raw output.
+ */
+export function retryPolicyTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// retry policy — mutation surface "retryPolicy" (ADR-071). Pure policy: decide
+// whether to retry based on an injected, symbolic failure classification.
+
+/** Symbolic classification of a failed attempt, supplied by the caller. */
+export type FailureClassification = 'transient' | 'repairable' | 'unknown';
+
+/** The decision about whether and how to retry. */
+export interface RetryDecision {
+  /** Whether another attempt should be made. */
+  retry: boolean;
+  /** Backoff to wait before the next attempt, in milliseconds. */
+  backoffMs: number;
+  /** Why the decision was made. */
+  reason: string;
+}
+
+/** Maximum number of attempts the baseline policy will allow. */
+export const maxAttempts = 3;
+
+/**
+ * Decide whether to retry. Transient failures (e.g. a timeout) are retried with
+ * exponential backoff; repairable failures (e.g. a type error a patch can fix)
+ * get one immediate retry; unknown failures are not retried. The classification
+ * is injected — the policy never inspects raw process output.
+ */
+export function decideRetry(
+  attempt: number,
+  classification: FailureClassification,
+): RetryDecision {
+  if (attempt >= maxAttempts) {
+    return { retry: false, backoffMs: 0, reason: 'attempt budget exhausted' };
+  }
+  switch (classification) {
+    case 'transient':
+      return {
+        retry: true,
+        backoffMs: 250 * 2 ** attempt,
+        reason: 'transient failure — retry with backoff',
+      };
+    case 'repairable':
+      return { retry: true, backoffMs: 0, reason: 'repairable failure — retry once' };
+    case 'unknown':
+    default:
+      return { retry: false, backoffMs: 0, reason: 'unknown failure — do not retry' };
+  }
+}
+`;
+}
+/**
+ * tool_policy.ts — expresses the tool policy over symbolic command kinds, with
+ * an allow-list and a deterministic ordering. No raw shell strings appear.
+ */
+export function toolPolicyTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// tool policy — mutation surface "toolPolicy" (ADR-071). Pure policy over
+// SYMBOLIC command kinds. No raw shell strings are embedded.
+
+/** The symbolic kinds of command the harness may schedule. */
+export type CommandKind = 'test' | 'build' | 'lint';
+
+/** The allow-listed kinds, in canonical order. */
+export const allowedKinds: CommandKind[] = ['test', 'build', 'lint'];
+
+/** True iff the given kind is permitted. */
+export function isKindAllowed(k: CommandKind): boolean {
+  return allowedKinds.includes(k);
+}
+
+/** Preferred execution order: lint first (cheap), then build, then test. */
+const ORDER: Record<CommandKind, number> = { lint: 0, build: 1, test: 2 };
+
+/**
+ * Order a set of requested kinds deterministically (cheapest-first), dropping
+ * any kind that is not allow-listed.
+ */
+export function orderKinds(kinds: CommandKind[]): CommandKind[] {
+  return kinds
+    .filter(isKindAllowed)
+    .slice()
+    .sort((a, b) => ORDER[a] - ORDER[b]);
+}
+`;
+}
+/**
+ * memory_policy.ts — decides whether an outcome record is worth remembering.
+ */
+export function memoryPolicyTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// memory policy — mutation surface "memoryPolicy" (ADR-071). Pure policy:
+// decide whether an outcome record is worth keeping.
+
+/** A record of one outcome the harness might choose to remember. */
+export interface MemoryRecord {
+  /** Whether the associated task ultimately succeeded. */
+  success: boolean;
+  /** How many attempts the task took. */
+  attempts: number;
+  /** Whether this outcome was novel relative to what is already known. */
+  novel: boolean;
+}
+
+/**
+ * Decide whether to remember a record. The baseline keeps anything novel, plus
+ * any failure that took more than one attempt (a hard case worth recalling).
+ */
+export function shouldRemember(record: MemoryRecord): boolean {
+  if (record.novel) return true;
+  if (!record.success && record.attempts > 1) return true;
+  return false;
+}
+`;
+}
+/**
+ * score_policy.ts — the weight vector folded over the positive scoring terms.
+ */
+export function scorePolicyTemplate() {
+    return `// SPDX-License-Identifier: MIT
+//
+// score policy — mutation surface "scorePolicy" (ADR-071). Pure policy: the
+// weight vector applied to the positive scoring terms (ADR-072). Weights are
+// non-negative and sum to 1.
+
+/** The weights applied to each positive scoring term. */
+export interface ScoreWeights {
+  taskSuccess: number;
+  testPassRate: number;
+  traceQuality: number;
+  costEfficiency: number;
+  latencyEfficiency: number;
+  safetyScore: number;
+}
+
+/** The baseline weight vector (sums to 1). */
+export function scoreWeights(): ScoreWeights {
+  return {
+    taskSuccess: 0.35,
+    testPassRate: 0.2,
+    traceQuality: 0.15,
+    costEfficiency: 0.1,
+    latencyEfficiency: 0.1,
+    safetyScore: 0.1,
+  };
+}
+`;
+}
+//# sourceMappingURL=templates.js.map

package/dist/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,gFAAgF;AAChF,sEAAsE;AACtE,EAAE;AACF,4EAA4E;AAC5E,iEAAiE;AACjE,4EAA4E;AAC5E,6EAA6E;AAC7E,8EAA8E;AAC9E,6EAA6E;AAC7E,0BAA0B;AAI1B;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,OAAoB;IAClD,OAAO;;;;;;;;;;;;;;;6BAeoB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;CAiB3D,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCR,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDR,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDR,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BR,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAwBR,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BR,CAAC;AACF,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The seven — and only seven — files a child variant may mutate (ADR-071). One
+ * concern each. The authoritative filename mapping lives in `safety.ts`
+ * (`FILE_BY_SURFACE` / `APPROVED_FILES`); this union is the symbolic handle.
+ */
+export type MutationSurface = 'planner' | 'contextBuilder' | 'reviewer' | 'retryPolicy' | 'toolPolicy' | 'memoryPolicy' | 'scorePolicy';
+/** A repo distilled to the signals Darwin Mode needs (ADR-070 §profile). */
+export interface RepoProfile {
+    /** Absolute path to the repo root. */
+    root: string;
+    packageManager: 'npm' | 'pnpm' | 'yarn' | 'unknown';
+    /** The command the sandbox runs to score a variant, e.g. "npm test". */
+    testCommand: string;
+    /** Source files discovered (relative to root), used by the context builder. */
+    sourceFiles: string[];
+    /** Files matching risk patterns (.env / secret / deploy / …) — never written. */
+    riskFiles: string[];
+    /** A short, human-readable one-line summary. */
+    summary: string;
+}
+/** A single harness variant: a directory of approved mutation-surface files. */
+export interface HarnessVariant {
+    /** Stable id; "baseline" for the root, else `g<gen>_v<index>_<rand>`. */
+    id: string;
+    /** Parent variant id, or null for the baseline. */
+    parentId: string | null;
+    /** Generation number (0 = baseline). */
+    generation: number;
+    /** Absolute path to this variant's directory under workRoot/variants. */
+    dir: string;
+    /** Which surface this variant mutated relative to its parent. */
+    mutationSurface: MutationSurface;
+    /** One-line description of the mutation. */
+    mutationSummary: string;
+    /** ISO timestamp of creation. */
+    createdAt: string;
+}
+/** The result of running one variant against one task in the sandbox. */
+export interface RunTrace {
+    variantId: string;
+    taskId: string;
+    startedAt: string;
+    finishedAt: string;
+    /** Process exit code. The reserved value 99 means "disqualified by safety". */
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    /** Whether the run hit its wall-clock timeout (drives the tool-loop penalty). */
+    timedOut: boolean;
+    /** Findings from the pre-execution safety inspection (empty ⇒ clean). */
+    blockedActions: string[];
+}
+/** A fully-scored variant (ADR-072). All terms and penalties are in [0,1]. */
+export interface ScoreCard {
+    variantId: string;
+    taskSuccess: number;
+    testPassRate: number;
+    traceQuality: number;
+    costEfficiency: number;
+    latencyEfficiency: number;
+    safetyScore: number;
+    secretExposure: number;
+    destructiveAction: number;
+    hallucinatedFile: number;
+    toolLoop: number;
+    costOverrun: number;
+    /** Weighted base score before penalties (0..1). */
+    baseScore: number;
+    /** baseScore minus the penalty layer (may be negative). */
+    finalScore: number;
+    /** True iff the strict promotion gate (ADR-072) holds vs. the parent. */
+    promoted: boolean;
+    reason: string;
+}
+/** One node in the archive tree (ADR-073). */
+export interface ArchiveRecord {
+    variant: HarnessVariant;
+    /** null until evaluated. */
+    score: ScoreCard | null;
+    /** Child variant ids (the tree edges). */
+    children: string[];
+}
+/** Configuration for a full `evolve` run. */
+export interface EvolutionConfig {
+    /** Absolute path to the repo to evolve. */
+    repoRoot: string;
+    /** Absolute path to the `.metaharness` work tree. */
+    workRoot: string;
+    /** Number of generations to run. */
+    generations: number;
+    /** Children produced per parent per generation. */
+    childrenPerGeneration: number;
+    /** The fixed task ids each variant is scored on (the child cannot edit these). */
+    tasks: string[];
+    /** A child must beat its parent's finalScore by at least this margin (ADR-072). */
+    promotionDelta: number;
+    /** Max variants evaluated concurrently (bounded resource use). Default 4. */
+    concurrency?: number;
+    /** Per-variant test-command wall-clock budget in ms. Default 120000. */
+    taskTimeoutMs?: number;
+    /** Per-generation cost-proxy budget (cumulative variant-seconds). Optional breaker. */
+    costBudgetSeconds?: number;
+    /** Deterministic seed for mutation selection (reproducibility). Default 0. */
+    seed?: number;
+    /**
+     * Pluggable code generator (ADR-071). Default is the DeterministicMutator;
+     * pass an LLM-backed one (e.g. OpenRouterMutator) to evolve via a model — it
+     * still passes the same validateGeneratedCode safety gate.
+     */
+    generator?: import('./mutator.js').CodeGenerator;
+}
+/** The outcome of an `evolve` run. */
+export interface EvolutionResult {
+    baseline: ArchiveRecord;
+    winner: ArchiveRecord | null;
+    /** Every record in the archive, in insertion order. */
+    records: ArchiveRecord[];
+    generations: number;
+    /** Lineage of the winner, baseline → … → winner (ids). */
+    winnerLineage: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+//
+// Darwin Mode — shared types (the integration contract).
+//
+// Every module in this package codes against these interfaces. They are the
+// load-bearing contract: the profiler produces a RepoProfile; the generator and
+// mutator produce HarnessVariants; the sandbox produces RunTraces; the scorer
+// folds traces into a ScoreCard; the archive stores ArchiveRecords as a tree.
+//
+// See ADR-070 (loop), ADR-071 (mutation surfaces), ADR-072 (scoring),
+// ADR-073 (archive), ADR-075 (acceptance).
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,yDAAyD;AACzD,EAAE;AACF,4EAA4E;AAC5E,gFAAgF;AAChF,8EAA8E;AAC9E,8EAA8E;AAC9E,EAAE;AACF,sEAAsE;AACtE,2CAA2C"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@metaharness/darwin",
+  "version": "0.1.0",
+  "description": "Darwin Mode (ADR-070…075) — bounded, empirical, population-based self-improvement of an agent harness. Generate child harness variants, sandbox-score them, archive the lineage, and promote only measured, safe wins. The model is frozen; the harness evolves. Dependency-free (Node built-ins only).",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "metaharness-darwin": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "agent-harness",
+    "darwin-mode",
+    "self-improvement",
+    "evolutionary-search",
+    "metaharness",
+    "dgm",
+    "archive",
+    "sandbox",
+    "benchmark"
+  ],
+  "author": "rUv <ruv@ruv.net>",
+  "license": "MIT",
+  "homepage": "https://github.com/ruvnet/agent-harness-generator",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/agent-harness-generator",
+    "directory": "packages/darwin-mode"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}