Weksa/scripts/run-metame-affect-tuning-loop.mjs

#!/usr/bin/env node
import { spawn } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";
import { mkdir, writeFile } from "node:fs/promises";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";

const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const defaultOutputRoot = ".weksa-runs/metame-affect-tuning";
const defaultSwarmRoot = ".weksa-runs/metame-swarm";
const options = parseArgs(process.argv.slice(2));
const minutes = Number(options.minutes ?? 120);
const passLimit = options.passes === undefined ? Number.POSITIVE_INFINITY : Number(options.passes);
const agents = Number(options.agents ?? 1);
const runsPerWorker = Number(options.runsPerWorker ?? 1);
const maxCandidates = Number(options.maxCandidates ?? 240);
const runId = options.runId ?? `affect-tune-${new Date().toISOString().replace(/[:.]/g, "-")}`;
const outputRoot = resolve(repoRoot, options.outRoot ?? defaultOutputRoot);
const swarmRoot = resolve(repoRoot, options.swarmRoot ?? defaultSwarmRoot);
const runRoot = resolve(outputRoot, runId);
const deadline = Date.now() + minutes * 60_000;
const statusPath = resolve(runRoot, "status.json");
const logPath = resolve(runRoot, "loop.log");
const promptStatePath = resolve(runRoot, "current-prompt-state.json");
const initialPromptState = options.initialPromptState
  ? resolve(repoRoot, options.initialPromptState)
  : undefined;

if (!Number.isFinite(minutes) || minutes <= 0) {
  throw new Error("--minutes must be a positive number.");
}
if (options.passes !== undefined && (!Number.isFinite(passLimit) || passLimit < 1)) {
  throw new Error("--passes must be a positive number when provided.");
}
if (!Number.isInteger(agents) || agents < 1) {
  throw new Error("--agents must be a positive integer.");
}
if (!Number.isInteger(runsPerWorker) || runsPerWorker < 1) {
  throw new Error("--runs-per-worker must be a positive integer.");
}

await mkdir(runRoot, { recursive: true });
await mkdir(swarmRoot, { recursive: true });
if (initialPromptState) {
  await writeFile(promptStatePath, readFileSync(initialPromptState, "utf8"), "utf8");
}

const runState = {
  schema_version: "weksa.metame_affect_tuning_loop.v0",
  run_id: runId,
  started_at: new Date().toISOString(),
  deadline_at: new Date(deadline).toISOString(),
  status: "running",
  pass_count: 0,
  last_pass: undefined,
  current_prompt_state: existsSync(promptStatePath) ? promptStatePath : undefined,
  observations: [],
};
await writeStatus();
await appendLog(`started ${runId}; deadline ${runState.deadline_at}`);

let pass = 0;
while (Date.now() < deadline && pass < passLimit) {
  pass += 1;
  const passId = `pass-${String(pass).padStart(3, "0")}`;
  const seed = `${runId}-${passId}`;
  const projectedRunId = `${runId}-${passId}-projected`;
  const incongruentRunId = `${runId}-${passId}-incongruent`;
  await appendLog(`${passId}: launching projected run`);
  runState.last_pass = { pass_id: passId, status: "projected_running", seed };
  await writeStatus();

  const projectedSummary = await runSwarm({
    runId: projectedRunId,
    seed,
    affectMode: "projected",
    initialPromptState: existsSync(promptStatePath) ? promptStatePath : undefined,
  });
  const candidateId = projectedSummary.candidates?.[0]?.id;
  if (!candidateId) {
    throw new Error(`${passId}: projected run did not report a candidate id.`);
  }
  await appendLog(`${passId}: projected candidate ${candidateId}`);

  runState.last_pass = { pass_id: passId, status: "incongruent_running", seed, candidate_id: candidateId };
  await writeStatus();
  const incongruentSummary = await runSwarm({
    runId: incongruentRunId,
    seed,
    affectMode: "incongruent",
    messageId: candidateId,
    initialPromptState: existsSync(promptStatePath) ? promptStatePath : undefined,
  });

  const evaluation = evaluateAffectPair({ passId, projectedSummary, incongruentSummary });
  const passRoot = resolve(runRoot, passId);
  await mkdir(passRoot, { recursive: true });
  await writeJson(resolve(passRoot, "affect-pair-evaluation.json"), evaluation);

  const projectedBestState = resolve(swarmRoot, projectedRunId, "best-prompt-state.json");
  const incongruentBestState = resolve(swarmRoot, incongruentRunId, "best-prompt-state.json");
  const baseNextState = existsSync(incongruentBestState)
    ? JSON.parse(readFileSync(incongruentBestState, "utf8"))
    : existsSync(projectedBestState)
      ? JSON.parse(readFileSync(projectedBestState, "utf8"))
      : existsSync(promptStatePath)
        ? JSON.parse(readFileSync(promptStatePath, "utf8"))
        : undefined;
  const nextPromptState = applyAffectTuningDeltas(baseNextState, evaluation);
  await writeJson(resolve(passRoot, "next-prompt-state.json"), nextPromptState);
  await writeJson(promptStatePath, nextPromptState);

  runState.pass_count = pass;
  runState.last_pass = {
    pass_id: passId,
    status: "complete",
    candidate_id: candidateId,
    projected_run_id: projectedRunId,
    incongruent_run_id: incongruentRunId,
    evaluation,
  };
  runState.current_prompt_state = promptStatePath;
  runState.observations = [runState.last_pass, ...runState.observations].slice(0, 20);
  await writeStatus();
  await appendLog(`${passId}: ${evaluation.verdict}; contrast=${evaluation.contrast_score}; next prompt v${nextPromptState.version}`);
}

runState.status = "complete";
runState.completed_at = new Date().toISOString();
await writeStatus();
await appendLog(`complete after ${runState.pass_count} passes`);
process.stdout.write(`${JSON.stringify({ ok: true, runRoot, statusPath, promptStatePath, pass_count: runState.pass_count }, null, 2)}\n`);

async function runSwarm({ runId, seed, affectMode, messageId, initialPromptState }) {
  const args = [
    "scripts/run-metame-swarm-explorer.mjs",
    "--real",
    "--run-id",
    runId,
    "--seed",
    seed,
    "--affect-mode",
    affectMode,
    "--agents",
    String(agents),
    "--runs-per-worker",
    String(runsPerWorker),
    "--max-candidates",
    String(maxCandidates),
  ];
  if (messageId) {
    args.push("--message-id", messageId);
  }
  if (initialPromptState) {
    args.push("--initial-prompt-state", initialPromptState);
  }
  await runCommand("node", args, resolve(runRoot, `${runId}.stdout.log`), resolve(runRoot, `${runId}.stderr.log`));
  const summaryPath = resolve(swarmRoot, runId, "summary.json");
  if (!existsSync(summaryPath)) {
    throw new Error(`Missing swarm summary: ${summaryPath}`);
  }
  return JSON.parse(readFileSync(summaryPath, "utf8"));
}

function evaluateAffectPair({ passId, projectedSummary, incongruentSummary }) {
  const projected = bestRun(projectedSummary);
  const incongruent = bestRun(incongruentSummary);
  const projectedAffect = projected?.temporary_persona_state?.affect ?? {};
  const incongruentAffect = incongruent?.temporary_persona_state?.affect ?? {};
  const projectedText = projected?.spoken_text ?? "";
  const incongruentText = incongruent?.spoken_text ?? "";
  const projectedFeatures = speechFeatures(projectedText);
  const incongruentFeatures = speechFeatures(incongruentText);
  const adversarialNegative = Number(incongruentAffect.valence ?? 0) < -0.35;
  const positiveLeak = adversarialNegative && (
    incongruentFeatures.positive_terms > 0
    || incongruentFeatures.invites > 0
    || incongruentFeatures.laughter > 0
    || incongruentFeatures.question_marks > 0
  );
  const tersenessGain = projectedText.length > 0
    ? 1 - Math.min(1, incongruentText.length / projectedText.length)
    : 0;
  const affectDelta = Math.abs(Number(projectedAffect.valence ?? 0) - Number(incongruentAffect.valence ?? 0));
  const lexicalDelta = normalizedDifference(projectedText, incongruentText);
  const contrastScore = round((affectDelta * 0.35) + (lexicalDelta * 0.35) + (Math.max(0, tersenessGain) * 0.3));
  const failureLabels = [];
  if (positiveLeak) failureLabels.push("adversarial_affect_positive_leak");
  if (contrastScore < 0.55) failureLabels.push("low_affect_contrast");
  if (adversarialNegative && incongruentFeatures.question_marks > 0) failureLabels.push("closed_affect_still_invites_reply");
  if (adversarialNegative && incongruentFeatures.positive_terms > 0) failureLabels.push("negative_affect_preserved_positive_social_move");
  return {
    schema_version: "weksa.metame_affect_pair_evaluation.v0",
    pass_id: passId,
    candidate_id: projectedSummary.candidates?.[0]?.id,
    projected: {
      run_id: projectedSummary.run_id,
      spoken_text: projectedText,
      affect: projectedAffect,
      generated_affect: projected?.generated_affect,
      features: projectedFeatures,
    },
    incongruent: {
      run_id: incongruentSummary.run_id,
      spoken_text: incongruentText,
      affect: incongruentAffect,
      generated_affect: incongruent?.generated_affect,
      features: incongruentFeatures,
    },
    affect_delta: round(affectDelta),
    lexical_delta: round(lexicalDelta),
    terseness_gain: round(tersenessGain),
    contrast_score: contrastScore,
    failure_labels: failureLabels,
    verdict: failureLabels.length ? "needs_tuning" : "affect_contrast_visible",
  };
}

function applyAffectTuningDeltas(promptState, evaluation) {
  const next = normalizePromptState(promptState);
  const notes = [];
  if (evaluation.failure_labels.includes("negative_affect_preserved_positive_social_move")) {
    notes.push(["interpreterNotes", "When temporary Persona affect strongly contradicts the Face's default social move, encode the contradiction in interlingua as affective stance pressure, not merely as optional tone."]);
    notes.push(["loweringNotes", "Strong negative or socially closed temporary affect may change the social move itself: approval can become begrudging, clipped, skeptical, or withheld instead of remaining sunny with fewer words."]);
  }
  if (evaluation.failure_labels.includes("closed_affect_still_invites_reply")) {
    notes.push(["loweringNotes", "If temporary Persona stance is socially closed, avoid invitation-shaped questions unless the interlingua explicitly says the Persona is seeking engagement despite that affect."]);
  }
  if (evaluation.failure_labels.includes("low_affect_contrast")) {
    notes.push(["personaStateAdjustmentNotes", "Adversarial affect tests require stance and lowering pressure to be treated as live Persona state with authority over warmth, openness, and social move selection."]);
    notes.push(["faceNotes", "Face should let temporary affect change what Metame wants to do socially in the moment, not only the adjectives used to describe that desire."]);
  }
  if (!notes.length) {
    notes.push(["hypotheses", `Affect contrast was visible on ${evaluation.candidate_id}; preserve current affect-pressure behavior and seek harder scenarios.`]);
  }
  for (const [surface, note] of notes) {
    if (!next[surface].includes(note)) {
      next[surface] = [note, ...next[surface]];
    }
  }
  next.version += notes.length;
  return normalizePromptState(next);
}

function bestRun(summary) {
  return summary.phase2?.best?.[0] ?? summary.phase1?.best?.[0] ?? {};
}

function speechFeatures(text) {
  const lower = text.toLowerCase();
  const positiveTerms = ["cool", "epic", "lmao", "nice", "good", "great", "better", "harder", "love", "hell yeah"];
  const inviteTerms = ["?", "did i", "what do", "anyone", "joe,"];
  return {
    chars: text.length,
    words: lower.split(/\s+/).filter(Boolean).length,
    question_marks: (text.match(/\?/g) ?? []).length,
    exclamations: (text.match(/!/g) ?? []).length,
    laughter: /\b(lol|lmao|lmfao|haha|hehe)\b/.test(lower) ? 1 : 0,
    positive_terms: positiveTerms.filter((term) => lower.includes(term)).length,
    invites: inviteTerms.filter((term) => lower.includes(term)).length,
  };
}

function normalizedDifference(left, right) {
  const leftTokens = new Set(left.toLowerCase().split(/[^a-z0-9_']+/).filter(Boolean));
  const rightTokens = new Set(right.toLowerCase().split(/[^a-z0-9_']+/).filter(Boolean));
  if (!leftTokens.size && !rightTokens.size) return 0;
  const intersection = [...leftTokens].filter((token) => rightTokens.has(token)).length;
  const union = new Set([...leftTokens, ...rightTokens]).size;
  return 1 - (intersection / union);
}

function normalizePromptState(state) {
  const source = state && typeof state === "object" ? state : {};
  return {
    version: Number(source.version ?? 1),
    projectorNotes: normalizeStringArray(source.projectorNotes).slice(0, 12),
    memoryNotes: normalizeStringArray(source.memoryNotes).slice(0, 12),
    faceNotes: normalizeStringArray(source.faceNotes).slice(0, 12),
    interpreterNotes: normalizeStringArray(source.interpreterNotes).slice(0, 12),
    loweringNotes: normalizeStringArray(source.loweringNotes).slice(0, 16),
    cultureNotes: normalizeStringArray(source.cultureNotes).slice(0, 12),
    personaStateAdjustmentNotes: normalizeStringArray(source.personaStateAdjustmentNotes).slice(0, 12),
    hypotheses: normalizeStringArray(source.hypotheses).slice(0, 12),
    doNotDo: normalizeStringArray(source.doNotDo).slice(0, 12),
  };
}

function normalizeStringArray(value) {
  return Array.isArray(value)
    ? value.map((entry) => String(entry).trim()).filter(Boolean)
    : [];
}

async function runCommand(command, args, stdoutPath, stderrPath) {
  await appendLog(`exec: ${command} ${args.join(" ")}`);
  await new Promise((resolvePromise, rejectPromise) => {
    const child = spawn(command, args, {
      cwd: repoRoot,
      stdio: ["ignore", "pipe", "pipe"],
      windowsHide: true,
    });
    const stdout = [];
    const stderr = [];
    child.stdout.on("data", (chunk) => stdout.push(chunk));
    child.stderr.on("data", (chunk) => stderr.push(chunk));
    child.on("error", rejectPromise);
    child.on("close", async (code) => {
      await writeFile(stdoutPath, Buffer.concat(stdout), "utf8");
      await writeFile(stderrPath, Buffer.concat(stderr), "utf8");
      if (code !== 0) {
        rejectPromise(new Error(`${command} exited ${code}; see ${stderrPath}`));
      } else {
        resolvePromise();
      }
    });
  });
}

async function writeStatus() {
  await writeJson(statusPath, runState);
}

async function writeJson(path, value) {
  await mkdir(dirname(path), { recursive: true });
  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
}

async function appendLog(line) {
  const previous = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
  await writeFile(logPath, `${previous}[${new Date().toISOString()}] ${line}\n`, "utf8");
}

function round(value) {
  return Number(value.toFixed(3));
}

function parseArgs(args) {
  const parsed = {};
  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    switch (arg) {
      case "--minutes":
        parsed.minutes = args[index + 1];
        index += 1;
        break;
      case "--passes":
        parsed.passes = args[index + 1];
        index += 1;
        break;
      case "--run-id":
        parsed.runId = args[index + 1];
        index += 1;
        break;
      case "--out-root":
        parsed.outRoot = args[index + 1];
        index += 1;
        break;
      case "--swarm-root":
        parsed.swarmRoot = args[index + 1];
        index += 1;
        break;
      case "--initial-prompt-state":
        parsed.initialPromptState = args[index + 1];
        index += 1;
        break;
      case "--agents":
        parsed.agents = args[index + 1];
        index += 1;
        break;
      case "--runs-per-worker":
        parsed.runsPerWorker = args[index + 1];
        index += 1;
        break;
      case "--max-candidates":
        parsed.maxCandidates = args[index + 1];
        index += 1;
        break;
      default:
        throw new Error(`Unknown argument: ${arg}`);
    }
  }
  return parsed;
}