claude-turing 4.4.0 → 4.6.0

package/config/defaults.yaml

@@ -35,6 +35,8 @@ placeholders:
   ML_DIR: "Directory for ML files relative to project root"
   DATA_SOURCE: "Path to training data file"
   METRIC_DIRECTION: "lower or higher — which direction is better"
+  LOWER_IS_BETTER: "Boolean derived from METRIC_DIRECTION for generated config.yaml"
+  MEMORY_DIR_NAME: "Filesystem-safe project name used for scoped agent memory"
 
 # Agent configuration
 agents:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-turing",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "type": "module",
   "description": "Autonomous ML research harness for Claude Code. The autoresearch loop as a formal protocol — iteratively trains, evaluates, and improves ML models with structured experiment tracking, convergence detection, immutable evaluation infrastructure, and safety guardrails.",
   "bin": {
@@ -34,21 +34,22 @@
     "ai-agents"
   ],
   "author": {
-    "name": "pragnition"
+    "name": "Prannaya Gupta"
   },
-  "homepage": "https://github.com/pragnition/turing",
+  "homepage": "https://github.com/ThePyProgrammer/turing",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pragnition/turing.git"
+    "url": "git+https://github.com/ThePyProgrammer/turing.git"
   },
   "bugs": {
-    "url": "https://github.com/pragnition/turing/issues"
+    "url": "https://github.com/ThePyProgrammer/turing/issues"
   },
   "license": "MIT",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "commander": "^13.0.0"
+    "commander": "^13.0.0",
+    "yaml": "^2.6.1"
   }
 }

package/src/command-registry.js

@@ -0,0 +1,151 @@
+import { readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = dirname(__dirname);
+const REGISTRY_PATH = join(PLUGIN_ROOT, 'config', 'commands.yaml');
+
+const COMMAND_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+const INVOCATION_MODES = new Set(['slash_only']);
+const MODEL_INVOCATIONS = new Set(['disabled', 'enabled']);
+const SCRIPT_LOCATIONS = new Set(['repo', 'scaffold']);
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function requireRecord(value, label) {
+  if (!isRecord(value)) {
+    throw new Error(`${label} must be a mapping`);
+  }
+  return value;
+}
+
+function requireNonEmptyString(value, label) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return value;
+}
+
+function requireNonEmptyStringList(value, label) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`${label} must be a non-empty string list`);
+  }
+
+  for (const [index, item] of value.entries()) {
+    requireNonEmptyString(item, `${label}[${index}]`);
+  }
+
+  return value;
+}
+
+function requireEnum(value, allowed, label) {
+  requireNonEmptyString(value, label);
+  if (!allowed.has(value)) {
+    throw new Error(`${label} must be one of: ${Array.from(allowed).join(', ')}`);
+  }
+  return value;
+}
+
+function validateEquivalentScript(value, commandName) {
+  const label = `commands.${commandName}.equivalent_script`;
+  const script = requireRecord(value, label);
+  const keys = Object.keys(script).sort();
+  const expectedKeys = ['location', 'path'];
+  if (keys.length !== expectedKeys.length || keys.some((key, index) => key !== expectedKeys[index])) {
+    throw new Error(`${label} must contain exactly: ${expectedKeys.join(', ')}`);
+  }
+
+  requireNonEmptyString(script.path, `${label}.path`);
+  requireEnum(
+    script.location,
+    SCRIPT_LOCATIONS,
+    `${label}.location`,
+  );
+}
+
+function validateCommand(commandName, value) {
+  if (!COMMAND_NAME_PATTERN.test(commandName)) {
+    throw new Error(`Invalid command name: ${commandName}`);
+  }
+
+  const command = requireRecord(value, `commands.${commandName}`);
+  requireNonEmptyString(command.description, `commands.${commandName}.description`);
+  requireNonEmptyString(command.lifecycle, `commands.${commandName}.lifecycle`);
+  requireEnum(command.invocation_mode, INVOCATION_MODES, `commands.${commandName}.invocation_mode`);
+  requireEnum(
+    command.model_invocation,
+    MODEL_INVOCATIONS,
+    `commands.${commandName}.model_invocation`,
+  );
+
+  if (typeof command.mutates_project !== 'boolean') {
+    throw new Error(`commands.${commandName}.mutates_project must be a boolean`);
+  }
+
+  requireNonEmptyStringList(command.tools, `commands.${commandName}.tools`);
+
+  if ('argument_hint' in command) {
+    requireNonEmptyString(command.argument_hint, `commands.${commandName}.argument_hint`);
+  }
+
+  if ('equivalent_script' in command) {
+    validateEquivalentScript(command.equivalent_script, commandName);
+  }
+}
+
+function validateRegistry(value) {
+  const registry = requireRecord(value, 'Command registry root');
+  const configFiles = requireNonEmptyStringList(registry.config_files, 'config_files');
+  const commands = requireRecord(registry.commands, 'commands');
+
+  for (const [commandName, command] of Object.entries(commands)) {
+    validateCommand(commandName, command);
+  }
+
+  return {
+    commands,
+    commandNames: Object.keys(commands).sort(),
+    configFiles: [...configFiles].sort(),
+  };
+}
+
+export async function loadCommandRegistry(registryPath = REGISTRY_PATH) {
+  let source;
+  try {
+    source = await readFile(registryPath, 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to read command registry at ${registryPath}: ${error.message}`);
+  }
+
+  let parsed;
+  try {
+    parsed = YAML.parse(source);
+  } catch (error) {
+    throw new Error(`Failed to parse command registry at ${registryPath}: ${error.message}`);
+  }
+
+  try {
+    return validateRegistry(parsed);
+  } catch (error) {
+    throw new Error(`Invalid command registry at ${registryPath}: ${error.message}`);
+  }
+}
+
+export async function getCommandNames(registryPath) {
+  const registry = await loadCommandRegistry(registryPath);
+  return registry.commandNames;
+}
+
+export async function getExpectedCommandPaths(registryPath) {
+  const names = await getCommandNames(registryPath);
+  return ['SKILL.md', ...names.map((name) => `${name}/SKILL.md`)];
+}
+
+export async function getConfigFiles(registryPath) {
+  const registry = await loadCommandRegistry(registryPath);
+  return registry.configFiles;
+}

package/src/install.js

@@ -9,48 +9,29 @@
  *   node src/install.js [--global] [--project]
  */
 
-import { readdir, copyFile, mkdir } from "fs/promises";
+import { readdir, copyFile, mkdir, cp } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { getTargetPaths } from "./paths.js";
 import { updateClaudeMd } from "./claude-md.js";
+import { getCommandNames, getConfigFiles } from "./command-registry.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PLUGIN_ROOT = join(__dirname, "..");
 
-// Single source of truth for sub-commands (DRY — used for dirs and file copy)
-const SUB_COMMANDS = [
-  "init", "train", "status", "compare", "sweep", "validate",
-  "try", "brief", "suggest", "explore", "design", "logbook", "poster",
-  "report", "mode", "preflight", "card", "seed", "reproduce",
-  "diagnose", "ablate", "frontier", "profile", "checkpoint", "export",
-  "lit", "paper", "queue", "retry", "fork",
-  "diff", "watch", "regress",
-  "ensemble", "stitch", "warm",
-  "scale", "budget", "distill",
-  "transfer", "audit",
-  "sanity", "baseline", "leak",
-  "xray", "sensitivity", "calibrate",
-  "feature", "curriculum",
-  "prune", "quantize", "merge", "surgery",
-  "trend", "flashback", "archive", "annotate", "search", "template", "replay",
-  "cite", "present", "changelog",
-  "onboard", "share", "review",
-  "whatif", "counterfactual", "simulate",
-  "update", "registry",
-  "postmortem", "doctor", "plan",
-];
 
 export async function install(opts = {}) {
   const scope = opts.global ? "global" : opts.project ? "project" : "global";
   const paths = getTargetPaths(scope);
+  const subCommands = await getCommandNames();
+  const configFiles = await getConfigFiles();
 
   console.log("Turing ML Research Harness — Installer");
   console.log(`Target: ${paths.commands} (${scope})`);
   console.log("");
 
   // Create directories for each sub-command + agents + config
-  for (const subDir of ["", "agents", "config", "rules", ...SUB_COMMANDS]) {
+  for (const subDir of ["", "agents", "config", "rules", "templates", ...subCommands]) {
     await mkdir(join(paths.commands, subDir), { recursive: true });
   }
 
@@ -62,13 +43,13 @@ export async function install(opts = {}) {
   console.log("  Router -> SKILL.md");
 
   // Copy sub-commands as <name>/SKILL.md
-  for (const cmd of SUB_COMMANDS) {
+  for (const cmd of subCommands) {
     await copyFile(
       join(PLUGIN_ROOT, "commands", `${cmd}.md`),
       join(paths.commands, cmd, "SKILL.md"),
     );
   }
-  console.log(`  ${SUB_COMMANDS.length} commands installed`);
+  console.log(`  ${subCommands.length} commands installed`);
 
   // Copy rules
   await copyFile(
@@ -88,20 +69,28 @@ export async function install(opts = {}) {
   console.log(`  ${agentFiles.length} agents installed`);
 
   // Copy config (static schema files only)
-  const CONFIG_FILES = [
-    "defaults.yaml", "lifecycle.toml", "taxonomy.toml",
-    "experiment_archetypes.yaml", "novelty_aliases.yaml",
-    "relationships.toml", "state.toml", "task_taxonomy.yaml",
-    "failure_modes.yaml",
-    "watch_alerts.yaml",
-  ];
-  for (const file of CONFIG_FILES) {
+  for (const file of configFiles) {
     await copyFile(
       join(PLUGIN_ROOT, "config", file),
       join(paths.config, file),
     );
   }
-  console.log(`  ${CONFIG_FILES.length} config files installed`);
+  console.log(`  ${configFiles.length} config files installed`);
+
+  // Copy templates used by /turing:init
+  await cp(
+    join(PLUGIN_ROOT, "templates"),
+    join(paths.commands, "templates"),
+    {
+      recursive: true,
+      force: true,
+      filter: (src) =>
+        !src.includes("__pycache__") &&
+        !src.includes(".pytest_cache") &&
+        !src.endsWith(".pyc"),
+    },
+  );
+  console.log("  Templates installed");
 
   // Update CLAUDE.md
   await updateClaudeMd(paths.claudeMd);

package/src/verify.js

@@ -8,97 +8,37 @@
  *   node src/verify.js [--scope global|project]
  */
 
-import { access } from "fs/promises";
-import { join } from "path";
+import { access, readdir } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { getConfigFiles, getExpectedCommandPaths } from "./command-registry.js";
 import { getTargetPaths } from "./paths.js";
 
-const EXPECTED_COMMANDS = [
-  "SKILL.md",
-  "init/SKILL.md",
-  "train/SKILL.md",
-  "status/SKILL.md",
-  "compare/SKILL.md",
-  "sweep/SKILL.md",
-  "validate/SKILL.md",
-  "try/SKILL.md",
-  "brief/SKILL.md",
-  "suggest/SKILL.md",
-  "explore/SKILL.md",
-  "design/SKILL.md",
-  "logbook/SKILL.md",
-  "poster/SKILL.md",
-  "report/SKILL.md",
-  "mode/SKILL.md",
-  "preflight/SKILL.md",
-  "card/SKILL.md",
-  "seed/SKILL.md",
-  "reproduce/SKILL.md",
-  "diagnose/SKILL.md",
-  "ablate/SKILL.md",
-  "frontier/SKILL.md",
-  "profile/SKILL.md",
-  "checkpoint/SKILL.md",
-  "export/SKILL.md",
-  "lit/SKILL.md",
-  "paper/SKILL.md",
-  "queue/SKILL.md",
-  "retry/SKILL.md",
-  "fork/SKILL.md",
-  "diff/SKILL.md",
-  "watch/SKILL.md",
-  "regress/SKILL.md",
-  "ensemble/SKILL.md",
-  "stitch/SKILL.md",
-  "warm/SKILL.md",
-  "scale/SKILL.md",
-  "budget/SKILL.md",
-  "distill/SKILL.md",
-  "transfer/SKILL.md",
-  "audit/SKILL.md",
-  "sanity/SKILL.md",
-  "baseline/SKILL.md",
-  "leak/SKILL.md",
-  "xray/SKILL.md",
-  "sensitivity/SKILL.md",
-  "calibrate/SKILL.md",
-  "feature/SKILL.md",
-  "curriculum/SKILL.md",
-  "prune/SKILL.md",
-  "quantize/SKILL.md",
-  "merge/SKILL.md",
-  "surgery/SKILL.md",
-  "trend/SKILL.md",
-  "flashback/SKILL.md",
-  "archive/SKILL.md",
-  "annotate/SKILL.md",
-  "search/SKILL.md",
-  "template/SKILL.md",
-  "replay/SKILL.md",
-  "cite/SKILL.md",
-  "present/SKILL.md",
-  "changelog/SKILL.md",
-  "onboard/SKILL.md",
-  "share/SKILL.md",
-  "review/SKILL.md",
-  "whatif/SKILL.md",
-  "counterfactual/SKILL.md",
-  "simulate/SKILL.md",
-  "update/SKILL.md",
-  "registry/SKILL.md",
-  "postmortem/SKILL.md",
-  "doctor/SKILL.md",
-  "plan/SKILL.md",
-];
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = join(__dirname, "..");
 
 const EXPECTED_AGENTS = ["ml-researcher.md", "ml-evaluator.md"];
 
-const EXPECTED_CONFIG = [
-  "defaults.yaml", "lifecycle.toml", "taxonomy.toml",
-  "experiment_archetypes.yaml", "novelty_aliases.yaml",
-  "relationships.toml", "state.toml", "task_taxonomy.yaml",
-  "failure_modes.yaml",
-  "watch_alerts.yaml",
-];
+async function templateFiles(root, relativeDir = "templates") {
+  const dir = join(root, relativeDir);
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    if (entry.name === "__pycache__" || entry.name === ".pytest_cache") {
+      continue;
+    }
+
+    const relativePath = `${relativeDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      files.push(...await templateFiles(root, relativePath));
+    } else if (!entry.name.endsWith(".pyc")) {
+      files.push(relativePath);
+    }
+  }
+
+  return files;
+}
 
 async function fileExists(path) {
   try {
@@ -110,8 +50,12 @@ async function fileExists(path) {
 }
 
 export async function verify(opts = {}) {
+  const expectedCommands = await getExpectedCommandPaths();
+  const expectedConfig = await getConfigFiles();
   const scopes = opts.scope ? [opts.scope] : ["global", "project"];
+  const expectedTemplates = await templateFiles(PLUGIN_ROOT);
   let found = false;
+  let totalMissing = 0;
 
   for (const scope of scopes) {
     const paths = getTargetPaths(scope);
@@ -124,7 +68,7 @@ export async function verify(opts = {}) {
     let missing = 0;
 
     console.log("Commands:");
-    for (const cmd of EXPECTED_COMMANDS) {
+    for (const cmd of expectedCommands) {
       const ok = await fileExists(join(paths.commands, cmd));
       console.log(`  ${ok ? "✓" : "✗"} commands/${cmd}`);
       if (!ok) missing++;
@@ -138,16 +82,24 @@ export async function verify(opts = {}) {
     }
 
     console.log("\nConfig:");
-    for (const cfg of EXPECTED_CONFIG) {
+    for (const cfg of expectedConfig) {
       const ok = await fileExists(join(paths.config, cfg));
       console.log(`  ${ok ? "✓" : "✗"} config/${cfg}`);
       if (!ok) missing++;
     }
 
+    console.log("\nTemplates:");
+    for (const template of expectedTemplates) {
+      const ok = await fileExists(join(paths.commands, template));
+      console.log(`  ${ok ? "✓" : "✗"} commands/${template}`);
+      if (!ok) missing++;
+    }
+
     // Check CLAUDE.md
     const claudeOk = await fileExists(paths.claudeMd);
     console.log(`\n  ${claudeOk ? "✓" : "✗"} CLAUDE.md`);
 
+    totalMissing += missing;
     console.log(
       `\n  ${missing === 0 ? "✓ Installation complete" : `✗ ${missing} files missing — run claude-turing install`}\n`,
     );
@@ -155,6 +107,11 @@ export async function verify(opts = {}) {
 
   if (!found) {
     console.log("\n✗ turing not found. Run: claude-turing install\n");
+    totalMissing++;
+  }
+
+  if (totalMissing > 0) {
+    process.exitCode = 1;
   }
 }
 

package/templates/README.md

@@ -4,7 +4,7 @@
 
 ## Overview
 
-This pipeline uses the [Turing](https://github.com/pragnition/turing) autoresearch pattern — an AI agent iteratively trains, evaluates, and improves models by modifying `train.py` while the evaluation infrastructure (`prepare.py`, `evaluate.py`) remains immutable.
+This pipeline uses the [Turing](https://github.com/ThePyProgrammer/turing) autoresearch pattern — an AI agent iteratively trains, evaluates, and improves models by modifying `train.py` while the evaluation infrastructure (`prepare.py`, `evaluate.py`) remains immutable.
 
 **Primary metric:** {{TARGET_METRIC}} ({{METRIC_DIRECTION}} is better)
 

package/templates/config.yaml

@@ -17,7 +17,7 @@ evaluation:
   metrics: ["{{TARGET_METRIC}}", "f1_weighted", "accuracy"]
   # Set to true for metrics where lower is better (mae, mse, rmse, loss)
   # Set to false for metrics where higher is better (accuracy, f1, auc)
-  lower_is_better: false  # {{METRIC_DIRECTION}} -- change to true if lower is better
+  lower_is_better: {{LOWER_IS_BETTER}}
 
   # Multi-seed configuration (Phase 10.1: /turing:seed)
   # Seeds used for seed studies — diverse values for good coverage

package/templates/program.md

@@ -43,7 +43,7 @@ git checkout -b exp/NNN-description
 
 ## Memory
 
-Read `.claude/agent-memory/ml-researcher/MEMORY.md` at the start of each session.
+Read `.claude/agent-memory/ml-researcher-{{MEMORY_DIR_NAME}}/MEMORY.md` at the start of each session.
 Update it after each experiment with:
 - Best result (if improved)
 - What was tried and why