1002 lines
33 KiB
JavaScript
1002 lines
33 KiB
JavaScript
#!/usr/bin/env node
|
|
import "dotenv/config";
|
|
|
|
import { spawn } from "node:child_process";
|
|
import { readFileSync } from "node:fs";
|
|
import { mkdir, readFile, writeFile } from "node:fs/promises";
|
|
import { homedir } from "node:os";
|
|
import { dirname, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const scriptDir = dirname(fileURLToPath(import.meta.url));
|
|
const repoRoot = resolve(scriptDir, "..");
|
|
const promptsRoot = resolve(repoRoot, "prompts");
|
|
const defaultScenarioPath = resolve(repoRoot, "scenarios", "cotsc-praxis-socratic-sermon.json");
|
|
const retrievalToolAllowlist = [
|
|
"search_history",
|
|
"get_message_context",
|
|
"list_indexed_repos",
|
|
"search_sources",
|
|
"get_source_context",
|
|
].join(",");
|
|
|
|
async function main() {
|
|
const options = parseArgs(process.argv.slice(2));
|
|
const scenarioPath = resolve(repoRoot, options.scenario ?? defaultScenarioPath);
|
|
const scenario = JSON.parse(await readFile(scenarioPath, "utf8"));
|
|
const maxPhases = numberOption(options["max-phases"], scenario.phases.length);
|
|
const maxDepth = numberOption(options["max-depth"], scenario.ctb?.maxFaceTurnsPerPhase ?? scenario.ctb?.branchingLimit ?? 12);
|
|
const generatedTurnBudget = numberOption(
|
|
options["generated-turn-budget"],
|
|
scenario.ctb?.generatedTurnBudgetPerPhase ?? scenario.ctb?.branchingLimit ?? maxDepth * (scenario.ctb?.choiceCount ?? 3),
|
|
);
|
|
const choiceCount = numberOption(options["choice-count"], scenario.ctb?.choiceCount ?? 3);
|
|
const faceModel = options["face-model"] ?? process.env.REPO_FACE_TURN_CODEX_MODEL ?? "gpt-5.4";
|
|
const mindModel = options["mind-model"] ?? process.env.REPO_FACE_MIND_CODEX_MODEL ?? "gpt-5.4";
|
|
const voidModel = options["void-model"] ?? options.model ?? process.env.REPO_FACE_MIND_CODEX_MODEL ?? "gpt-5.4";
|
|
const faceReasoningEffort = options["face-reasoning-effort"] ?? process.env.REPO_FACE_TURN_CODEX_REASONING_EFFORT ?? "low";
|
|
const mindReasoningEffort = options["mind-reasoning-effort"] ?? process.env.REPO_FACE_MIND_CODEX_REASONING_EFFORT ?? "none";
|
|
const voidReasoningEffort = options["void-reasoning-effort"] ?? "low";
|
|
const foldMode = options["void-fold-mode"] ?? "generated";
|
|
const turnInterpreterMode = options["turn-interpreter-mode"] ?? "model";
|
|
const outPath = resolve(repoRoot, options.out ?? scenario.outputInkPath);
|
|
const receiptPath = resolve(repoRoot, options.receipts ?? scenario.receiptPath);
|
|
const progressPath = resolve(repoRoot, options.progress ?? ".voidbot/artifacts/socratic-ink/progress.json");
|
|
const globalAgentDoctrine = await loadGlobalAgentDoctrine();
|
|
const basePromptCache = new Map();
|
|
const voiceCardCache = new Map();
|
|
const receipts = {
|
|
schemaVersion: "voidbot.socratic_ink_receipts.v0",
|
|
scenarioPath,
|
|
generatedAt: new Date().toISOString(),
|
|
options: {
|
|
maxPhases,
|
|
maxDepth,
|
|
generatedTurnBudget,
|
|
choiceCount,
|
|
faceModel,
|
|
mindModel,
|
|
voidModel,
|
|
faceReasoningEffort,
|
|
mindReasoningEffort,
|
|
voidReasoningEffort,
|
|
foldMode,
|
|
turnInterpreterMode,
|
|
},
|
|
faceTurns: [],
|
|
voidFolds: [],
|
|
};
|
|
|
|
const actors = scenario.actors.map((actor, index) => ({
|
|
...actor,
|
|
displayName: actor.displayName ?? actor.identityId,
|
|
speed: Number.isFinite(actor.speed) ? actor.speed : 1,
|
|
order: index,
|
|
nextReady: index / Math.max(1, scenario.actors.length),
|
|
}));
|
|
|
|
const ink = [];
|
|
ink.push(`// ghostlight.scenario: ${scenario.scenarioId}`);
|
|
ink.push(`// ghostlight.generated_at: ${receipts.generatedAt}`);
|
|
ink.push(`// ghostlight.receipts: ${toInkCommentPath(receiptPath)}`);
|
|
ink.push(`VAR face_turns = 0`);
|
|
ink.push(`VAR void_folds = 0`);
|
|
ink.push("");
|
|
ink.push(`// if.render: speaker-panel`);
|
|
if (scenario.scene?.id) {
|
|
ink.push(`// if.scene_id: ${scenario.scene.id}`);
|
|
}
|
|
if (scenario.scene?.background) {
|
|
ink.push(`// if.background: ${scenario.scene.background}`);
|
|
}
|
|
ink.push("");
|
|
ink.push(`# ${scenario.title}`);
|
|
if (scenario.subtitle) {
|
|
ink.push(`# ${scenario.subtitle}`);
|
|
}
|
|
ink.push("");
|
|
const introduction = Array.isArray(scenario.introduction) ? scenario.introduction : [];
|
|
ink.push(`-> ${introduction.length ? "intro_1" : "phase_1"}`);
|
|
ink.push("");
|
|
for (let index = 0; index < introduction.length; index += 1) {
|
|
const knot = `intro_${index + 1}`;
|
|
const next = index + 1 < introduction.length ? `intro_${index + 2}` : "phase_1";
|
|
writeSpeakerKnot(ink, knot, scenario.voidRole?.displayName ?? "Void", scenario.voidRole?.avatarPath, introduction[index]);
|
|
ink.push(`-> ${next}`);
|
|
ink.push("");
|
|
}
|
|
|
|
const phaseCount = Math.min(maxPhases, scenario.phases.length);
|
|
for (let phaseIndex = 0; phaseIndex < phaseCount; phaseIndex += 1) {
|
|
const phase = scenario.phases[phaseIndex];
|
|
const nextPhaseKnot = phaseIndex + 1 < phaseCount ? `phase_${phaseIndex + 2}` : "closing";
|
|
const phaseCtb = cloneCtb(actors, phaseIndex * choiceCount);
|
|
const phaseOpening = normalizeUtterances(phase.voidOpening);
|
|
writeSpeakerSequence(
|
|
ink,
|
|
`phase_${phaseIndex + 1}`,
|
|
scenario.voidRole?.displayName ?? "Void",
|
|
scenario.voidRole?.avatarPath,
|
|
phaseOpening,
|
|
nodeName(phaseIndex, []),
|
|
[
|
|
`ghostlight.phase_id: ${phase.phaseId}`,
|
|
`ghostlight.topic: ${phase.topic}`,
|
|
],
|
|
);
|
|
|
|
await buildBranchNode({
|
|
scenario,
|
|
phase,
|
|
phaseIndex,
|
|
nextPhaseKnot,
|
|
depth: 0,
|
|
maxDepth,
|
|
generatedTurnBudget,
|
|
choiceCount,
|
|
ctb: phaseCtb,
|
|
phaseState: {
|
|
generatedFaceTurns: 0,
|
|
},
|
|
transcript: [
|
|
...introduction.map((text) => ({ speaker: "Void", text })),
|
|
...phaseOpening.map((text) => ({ speaker: "Void", text })),
|
|
],
|
|
voidLine: phaseOpening.at(-1) ?? "",
|
|
basePromptCache,
|
|
voiceCardCache,
|
|
globalAgentDoctrine,
|
|
faceModel,
|
|
mindModel,
|
|
voidModel,
|
|
faceReasoningEffort,
|
|
mindReasoningEffort,
|
|
voidReasoningEffort,
|
|
foldMode,
|
|
turnInterpreterMode,
|
|
progressPath,
|
|
ink,
|
|
receipts,
|
|
});
|
|
}
|
|
|
|
writeSpeakerSequence(ink, "closing", scenario.voidRole?.displayName ?? "Void", scenario.voidRole?.avatarPath, normalizeUtterances(scenario.closing), "END");
|
|
|
|
await mkdir(dirname(outPath), { recursive: true });
|
|
await mkdir(dirname(receiptPath), { recursive: true });
|
|
await writeFile(outPath, `${ink.join("\n")}\n`, "utf8");
|
|
await writeFile(receiptPath, `${JSON.stringify(receipts, null, 2)}\n`, "utf8");
|
|
process.stdout.write(`${JSON.stringify({
|
|
ok: true,
|
|
scenarioId: scenario.scenarioId,
|
|
outPath,
|
|
receiptPath,
|
|
faceTurns: receipts.faceTurns.length,
|
|
voidFolds: receipts.voidFolds.length,
|
|
}, null, 2)}\n`);
|
|
}
|
|
|
|
async function buildBranchNode(input) {
|
|
const knot = nodeName(input.phaseIndex, input.transcriptPath ?? []);
|
|
const path = input.transcriptPath ?? [];
|
|
input.ink.push(`=== ${knot} ===`);
|
|
input.ink.push(`// ghostlight.branch_depth: ${input.depth}`);
|
|
input.ink.push(`// ghostlight.ctb_next: ${nextActors(input.ctb, input.choiceCount).map((actor) => actor.identityId).join(",")}`);
|
|
input.ink.push(`// ghostlight.generated_face_turns: ${input.phaseState.generatedFaceTurns}/${input.generatedTurnBudget}`);
|
|
input.ink.push(`// ghostlight.selected_turn_budget: ${input.depth}/${input.maxDepth}`);
|
|
input.ink.push("");
|
|
|
|
if (input.depth >= input.maxDepth) {
|
|
await writeForcedFold(input, path);
|
|
return;
|
|
}
|
|
|
|
const reusableOptions = (input.reusableOptions ?? [])
|
|
.filter((option) => option.identityId !== input.lastSpeakerId)
|
|
.slice(0, input.choiceCount);
|
|
const candidates = [...reusableOptions];
|
|
const reservedIds = new Set(candidates.map((option) => option.identityId));
|
|
const perspectiveSlots = assignPerspectiveSlots(input, candidates.length, input.choiceCount);
|
|
for (const actor of nextActors(input.ctb, input.choiceCount * 3)) {
|
|
if (
|
|
candidates.length >= input.choiceCount ||
|
|
input.phaseState.generatedFaceTurns >= input.generatedTurnBudget
|
|
) {
|
|
break;
|
|
}
|
|
if (reservedIds.has(actor.identityId)) {
|
|
continue;
|
|
}
|
|
const readerPerspective = perspectiveSlots[candidates.length] ?? defaultReaderPerspective(input.phase, input.depth, candidates.length);
|
|
const turn = await generateFaceTurn({ ...input, actor, readerPerspective });
|
|
input.phaseState.generatedFaceTurns += 1;
|
|
const option = {
|
|
...turn,
|
|
identityId: actor.identityId,
|
|
actor,
|
|
generatedAtDepth: input.depth,
|
|
readerPerspective,
|
|
};
|
|
candidates.push(option);
|
|
reservedIds.add(actor.identityId);
|
|
}
|
|
|
|
if (candidates.length === 0) {
|
|
await writeForcedFold(input, path);
|
|
return;
|
|
}
|
|
|
|
const branches = [];
|
|
for (const option of candidates) {
|
|
const actor = option.actor;
|
|
const turn = option;
|
|
const choiceKnot = afterChoiceName(input.phaseIndex, path, actor.identityId);
|
|
input.ink.push(`+ [${formatChoiceLabel(turn.displayName, turn.choiceLabel)}]`);
|
|
input.ink.push(` -> ${choiceKnot}`);
|
|
input.ink.push("");
|
|
|
|
const branchCtb = spendActor(input.ctb, actor, input.scenario.ctb?.recoveryBase ?? 1);
|
|
const branchTranscript = [
|
|
...input.transcript,
|
|
{ speaker: turn.displayName, text: turn.speech },
|
|
];
|
|
const branchPath = [...path, actor.identityId];
|
|
const nextReusableOptions = candidates
|
|
.filter((candidate) => candidate.identityId !== actor.identityId)
|
|
.map((candidate) => ({ ...candidate }));
|
|
branches.push({
|
|
actor,
|
|
turn,
|
|
choiceKnot,
|
|
branchCtb,
|
|
branchTranscript,
|
|
branchPath,
|
|
nextReusableOptions,
|
|
});
|
|
}
|
|
|
|
for (const branch of branches) {
|
|
const {
|
|
actor,
|
|
turn,
|
|
choiceKnot,
|
|
branchCtb,
|
|
branchTranscript,
|
|
branchPath,
|
|
nextReusableOptions,
|
|
} = branch;
|
|
writeSpeakerKnot(
|
|
input.ink,
|
|
choiceKnot,
|
|
turn.displayName,
|
|
actor.avatarPath,
|
|
turn.speech,
|
|
[
|
|
`ghostlight.selected_face: ${actor.identityId}`,
|
|
`ghostlight.reader_perspective: ${turn.readerPerspective?.label ?? ""}`,
|
|
`ghostlight.unspent_faces: ${nextReusableOptions.map((candidate) => candidate.identityId).join(",")}`,
|
|
],
|
|
);
|
|
input.ink.push(`~ face_turns += 1`);
|
|
if (input.depth + 1 < input.maxDepth) {
|
|
const continueKnot = nodeName(input.phaseIndex, branchPath);
|
|
input.ink.push(`-> ${continueKnot}`);
|
|
input.ink.push("");
|
|
await buildBranchNode({
|
|
...input,
|
|
depth: input.depth + 1,
|
|
ctb: branchCtb,
|
|
transcript: branchTranscript,
|
|
voidLine: turn.speech,
|
|
transcriptPath: branchPath,
|
|
reusableOptions: nextReusableOptions,
|
|
lastSpeakerId: actor.identityId,
|
|
});
|
|
} else {
|
|
const fold = await generateVoidFold({
|
|
...input,
|
|
transcript: branchTranscript,
|
|
actor,
|
|
});
|
|
input.ink.push(`-> ${foldName(input.phaseIndex, branchPath)}`);
|
|
input.ink.push("");
|
|
writeSpeakerSequence(
|
|
input.ink,
|
|
foldName(input.phaseIndex, branchPath),
|
|
input.scenario.voidRole?.displayName ?? "Void",
|
|
input.scenario.voidRole?.avatarPath,
|
|
fold.panels ?? [fold.text],
|
|
input.nextPhaseKnot,
|
|
[],
|
|
[`~ void_folds += 1`],
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function writeForcedFold(input, path) {
|
|
const fold = await generateVoidFold(input);
|
|
const foldStart = foldName(input.phaseIndex, path);
|
|
input.ink.push(`+ [Void: Bring the thread back to the lesson]`);
|
|
input.ink.push(` -> ${foldStart}`);
|
|
input.ink.push("");
|
|
writeSpeakerSequence(
|
|
input.ink,
|
|
foldStart,
|
|
input.scenario.voidRole?.displayName ?? "Void",
|
|
input.scenario.voidRole?.avatarPath,
|
|
fold.panels ?? [fold.text],
|
|
input.nextPhaseKnot,
|
|
[],
|
|
[`~ void_folds += 1`],
|
|
);
|
|
}
|
|
|
|
async function generateFaceTurn(input) {
|
|
const actorVoiceCard = await getActorVoiceCard(input.actor, input.basePromptCache, input.voiceCardCache, input);
|
|
const transcript = renderTranscript(input.transcript);
|
|
const prompt = renderTemplate("socratic-ink-face-turn.prompt.md", {
|
|
actorVoiceCard,
|
|
title: input.scenario.title,
|
|
phaseTopic: input.phase.topic,
|
|
phaseSetup: input.phase.laySetup ?? "Void has introduced only the immediate question. Keep the response accessible.",
|
|
commonCounterarguments: renderList(input.phase.commonCounterarguments ?? input.scenario.commonCounterarguments ?? []),
|
|
readerPerspective: renderReaderPerspective(input.readerPerspective),
|
|
voidLine: input.voidLine,
|
|
transcript,
|
|
actorRole: input.actor.role ?? "",
|
|
displayName: input.actor.displayName ?? input.actor.identityId,
|
|
depth: input.depth,
|
|
});
|
|
const faceRun = await runCodex(prompt, {
|
|
model: input.faceModel,
|
|
reasoningEffort: input.faceReasoningEffort,
|
|
mcpMode: "real-readonly",
|
|
timeoutMs: 240_000,
|
|
});
|
|
const faceText = extractFinalText(parseJsonEvents(faceRun.stdout), faceRun.stdout);
|
|
const parsedFace = parseFaceResponse(faceText, input.actor);
|
|
const mindPrompt = renderTemplate("socratic-ink-turn-interpreter.prompt.md", {
|
|
displayName: input.actor.displayName ?? input.actor.identityId,
|
|
actorRole: input.actor.role ?? "",
|
|
phaseSetup: input.phase.laySetup ?? "",
|
|
voidLine: input.voidLine,
|
|
transcript,
|
|
draftResponse: faceText,
|
|
});
|
|
let mindRun;
|
|
let mindText;
|
|
let parsedMind;
|
|
if (input.turnInterpreterMode === "local") {
|
|
parsedMind = localArticleInterpretation(parsedFace, faceText, input.actor);
|
|
mindRun = { code: 0, durationMs: 0, stderr: "" };
|
|
mindText = JSON.stringify(parsedMind);
|
|
} else {
|
|
mindRun = await runCodex(mindPrompt, {
|
|
model: input.mindModel,
|
|
reasoningEffort: input.mindReasoningEffort,
|
|
mcpMode: "none",
|
|
timeoutMs: 240_000,
|
|
});
|
|
mindText = extractFinalText(parseJsonEvents(mindRun.stdout), mindRun.stdout);
|
|
parsedMind = parseArticleInterpreterOutput(mindText);
|
|
}
|
|
const speech = cleanSpeakerPrefix(parsedMind.speech || parsedFace.speech || faceText, input.actor.displayName ?? input.actor.identityId);
|
|
const choiceLabel = parsedMind.choiceLabel || parsedFace.choiceLabel || `${input.actor.displayName ?? input.actor.identityId}: ${speech}`;
|
|
const receipt = {
|
|
phaseId: input.phase.phaseId,
|
|
depth: input.depth,
|
|
identityId: input.actor.identityId,
|
|
displayName: input.actor.displayName ?? input.actor.identityId,
|
|
readerPerspective: input.readerPerspective,
|
|
prompt,
|
|
face: {
|
|
exitCode: faceRun.code,
|
|
durationMs: faceRun.durationMs,
|
|
text: faceText,
|
|
parsed: parsedFace,
|
|
stderrTail: faceRun.stderr.slice(-2000),
|
|
},
|
|
mind: {
|
|
mode: input.turnInterpreterMode,
|
|
prompt: input.turnInterpreterMode === "local" ? undefined : mindPrompt,
|
|
exitCode: mindRun.code,
|
|
durationMs: mindRun.durationMs,
|
|
text: mindText,
|
|
parsed: parsedMind,
|
|
stderrTail: mindRun.stderr.slice(-2000),
|
|
},
|
|
selectedSpeech: speech,
|
|
choiceLabel,
|
|
};
|
|
input.receipts.faceTurns.push(receipt);
|
|
await writeProgress(input);
|
|
return {
|
|
displayName: input.actor.displayName ?? input.actor.identityId,
|
|
speech,
|
|
choiceLabel,
|
|
};
|
|
}
|
|
|
|
async function generateVoidFold(input) {
|
|
if (input.foldMode === "template") {
|
|
const panels = input.phase.foldPanels?.length
|
|
? normalizeUtterances(input.phase.foldPanels)
|
|
: [`Hold that answer.`, `The next question is simpler and sharper: ${input.phase.foldTarget}`];
|
|
const text = panels.join(" ");
|
|
input.receipts.voidFolds.push({ phaseId: input.phase.phaseId, depth: input.depth, mode: "template", text, panels });
|
|
await writeProgress(input);
|
|
return { text, panels };
|
|
}
|
|
const prompt = renderTemplate("socratic-ink-void-fold.prompt.md", {
|
|
globalAgentDoctrine: input.globalAgentDoctrine,
|
|
title: input.scenario.title,
|
|
phaseTopic: input.phase.topic,
|
|
phaseLesson: input.phase.lesson,
|
|
foldTarget: input.phase.foldTarget,
|
|
transcript: renderTranscript(input.transcript),
|
|
});
|
|
const run = await runCodex(prompt, {
|
|
model: input.voidModel,
|
|
reasoningEffort: input.voidReasoningEffort,
|
|
mcpMode: "none",
|
|
timeoutMs: 180_000,
|
|
});
|
|
const text = cleanSpeakerPrefix(extractFinalText(parseJsonEvents(run.stdout), run.stdout), "Void");
|
|
const panels = splitVoidPanels(text);
|
|
input.receipts.voidFolds.push({
|
|
phaseId: input.phase.phaseId,
|
|
depth: input.depth,
|
|
mode: "generated",
|
|
prompt,
|
|
exitCode: run.code,
|
|
durationMs: run.durationMs,
|
|
text,
|
|
panels,
|
|
stderrTail: run.stderr.slice(-2000),
|
|
});
|
|
await writeProgress(input);
|
|
return { text, panels };
|
|
}
|
|
|
|
async function getBaseFacePrompt(identityId, cache) {
|
|
if (cache.has(identityId)) {
|
|
return cache.get(identityId);
|
|
}
|
|
const outPath = resolve(repoRoot, ".voidbot", "artifacts", "socratic-ink", "base-prompts", `${identityId}.md`);
|
|
await mkdir(dirname(outPath), { recursive: true });
|
|
await runProcess(process.execPath, [
|
|
resolve(repoRoot, "node_modules", "tsx", "dist", "cli.mjs"),
|
|
resolve(repoRoot, "scripts", "run-repo-face-heartbeats.ts"),
|
|
"--assemble-prompt",
|
|
identityId,
|
|
"--out",
|
|
outPath,
|
|
], { cwd: repoRoot, timeoutMs: 180_000 });
|
|
const prompt = await readFile(outPath, "utf8");
|
|
cache.set(identityId, prompt);
|
|
return prompt;
|
|
}
|
|
|
|
async function getActorVoiceCard(actor, basePromptCache, voiceCardCache, input) {
|
|
if (voiceCardCache.has(actor.identityId)) {
|
|
return voiceCardCache.get(actor.identityId);
|
|
}
|
|
const baseFacePrompt = await getBaseFacePrompt(actor.identityId, basePromptCache);
|
|
const prompt = renderTemplate("socratic-ink-face-projector.prompt.md", {
|
|
baseFacePrompt,
|
|
actorRole: actor.role ?? "",
|
|
});
|
|
const run = await runCodex(prompt, {
|
|
model: input.mindModel,
|
|
reasoningEffort: input.mindReasoningEffort,
|
|
mcpMode: "none",
|
|
timeoutMs: 180_000,
|
|
});
|
|
const text = extractFinalText(parseJsonEvents(run.stdout), run.stdout);
|
|
const voiceCard = section(text, "VOICE CARD") || text.trim();
|
|
voiceCardCache.set(actor.identityId, voiceCard);
|
|
input.receipts.voiceCards ??= [];
|
|
input.receipts.voiceCards.push({
|
|
identityId: actor.identityId,
|
|
displayName: actor.displayName ?? actor.identityId,
|
|
prompt,
|
|
exitCode: run.code,
|
|
durationMs: run.durationMs,
|
|
text,
|
|
voiceCard,
|
|
stderrTail: run.stderr.slice(-2000),
|
|
});
|
|
await writeProgress(input);
|
|
return voiceCard;
|
|
}
|
|
|
|
async function writeProgress(input) {
|
|
if (!input.progressPath) {
|
|
return;
|
|
}
|
|
await mkdir(dirname(input.progressPath), { recursive: true });
|
|
await writeFile(input.progressPath, `${JSON.stringify({
|
|
scenarioId: input.scenario.scenarioId,
|
|
generatedAt: new Date().toISOString(),
|
|
phaseId: input.phase?.phaseId,
|
|
generatedFaceTurns: input.phaseState?.generatedFaceTurns,
|
|
selectedTurnBudget: input.maxDepth,
|
|
faceTurns: input.receipts.faceTurns.length,
|
|
voidFolds: input.receipts.voidFolds.length,
|
|
voiceCards: input.receipts.voiceCards?.length ?? 0,
|
|
}, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
function assignPerspectiveSlots(input, alreadyFilled, choiceCount) {
|
|
const slots = [];
|
|
for (let index = alreadyFilled; index < choiceCount; index += 1) {
|
|
slots[index] = defaultReaderPerspective(input.phase, input.depth, index);
|
|
}
|
|
return slots;
|
|
}
|
|
|
|
function defaultReaderPerspective(phase, depth, optionIndex) {
|
|
const phasePerspectives = Array.isArray(phase.readerPerspectives) ? phase.readerPerspectives : [];
|
|
const commonCounterarguments = Array.isArray(phase.commonCounterarguments) ? phase.commonCounterarguments : [];
|
|
const source = phasePerspectives.length ? phasePerspectives : commonCounterarguments.map((entry, index) => ({
|
|
label: `Reader concern ${index + 1}`,
|
|
stance: entry,
|
|
emotionalRegister: "curious but unconvinced",
|
|
}));
|
|
const selected = source[(depth * 3 + optionIndex) % Math.max(1, source.length)] ?? {};
|
|
return {
|
|
label: selected.label ?? `Reader concern ${optionIndex + 1}`,
|
|
stance: selected.stance ?? String(selected),
|
|
emotionalRegister: selected.emotionalRegister ?? selected.tone ?? "plain-spoken uncertainty",
|
|
};
|
|
}
|
|
|
|
function renderReaderPerspective(value) {
|
|
if (!value) {
|
|
return "- Label: ordinary reader reaction\n- Stance: Answer Void from a concrete layperson worry.\n- Emotional register: plain-spoken uncertainty.";
|
|
}
|
|
return [
|
|
`- Label: ${cleanSpeech(value.label)}`,
|
|
`- Stance: ${cleanSpeech(value.stance)}`,
|
|
`- Emotional register: ${cleanSpeech(value.emotionalRegister)}`,
|
|
].join("\n");
|
|
}
|
|
|
|
function nextActors(ctb, count) {
|
|
return [...ctb]
|
|
.sort((left, right) =>
|
|
left.nextReady - right.nextReady ||
|
|
right.speed - left.speed ||
|
|
left.order - right.order
|
|
)
|
|
.slice(0, count);
|
|
}
|
|
|
|
function spendActor(ctb, selected, recoveryBase) {
|
|
const clock = selected.nextReady;
|
|
return ctb.map((actor) => {
|
|
if (actor.identityId !== selected.identityId) {
|
|
return { ...actor };
|
|
}
|
|
return {
|
|
...actor,
|
|
nextReady: clock + (recoveryBase / Math.max(0.1, actor.speed)),
|
|
};
|
|
});
|
|
}
|
|
|
|
function cloneCtb(actors, phaseOffset = 0) {
|
|
const count = Math.max(1, actors.length);
|
|
return actors.map((actor) => ({
|
|
...actor,
|
|
nextReady: ((actor.order - phaseOffset) % count + count) % count / count,
|
|
}));
|
|
}
|
|
|
|
function nodeName(phaseIndex, path) {
|
|
return `p${phaseIndex + 1}_${path.length === 0 ? "root" : path.map(safeId).join("_")}`;
|
|
}
|
|
|
|
function afterChoiceName(phaseIndex, path, identityId) {
|
|
return `${nodeName(phaseIndex, path)}__after_${safeId(identityId)}`;
|
|
}
|
|
|
|
function foldName(phaseIndex, path) {
|
|
return `${nodeName(phaseIndex, path)}__void_fold`;
|
|
}
|
|
|
|
function safeId(value) {
|
|
return String(value).toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "x";
|
|
}
|
|
|
|
function writeSpeakerKnot(ink, knot, speaker, avatarPath, speech, comments = []) {
|
|
ink.push(`=== ${knot} ===`);
|
|
for (const comment of comments) {
|
|
ink.push(`// ${comment}`);
|
|
}
|
|
ink.push(`# speaker: ${speaker}`);
|
|
if (avatarPath) {
|
|
ink.push(`# avatar: ${avatarPath}`);
|
|
}
|
|
ink.push(cleanSpeakerPrefix(speech, speaker));
|
|
}
|
|
|
|
function writeSpeakerSequence(ink, baseKnot, speaker, avatarPath, utterances, finalTarget, comments = [], beforeFinalDivert = []) {
|
|
const panels = normalizeUtterances(utterances);
|
|
for (let index = 0; index < panels.length; index += 1) {
|
|
const knot = index === 0 ? baseKnot : `${baseKnot}_${index + 1}`;
|
|
const next = index + 1 < panels.length ? `${baseKnot}_${index + 2}` : finalTarget;
|
|
writeSpeakerKnot(ink, knot, speaker, avatarPath, panels[index], index === 0 ? comments : []);
|
|
if (index + 1 === panels.length) {
|
|
for (const line of beforeFinalDivert) {
|
|
ink.push(line);
|
|
}
|
|
}
|
|
ink.push(next === "END" ? "-> END" : `-> ${next}`);
|
|
ink.push("");
|
|
}
|
|
}
|
|
|
|
function normalizeUtterances(value) {
|
|
const raw = Array.isArray(value) ? value : [value];
|
|
const cleaned = raw.map((entry) => cleanSpeech(entry)).filter(Boolean);
|
|
return cleaned.length ? cleaned : [""];
|
|
}
|
|
|
|
function splitVoidPanels(value) {
|
|
const text = cleanSpeakerPrefix(value, "Void");
|
|
const sentences = text.match(/[^.!?]+[.!?]+(?:["']|\)|\])?/g) ?? [text];
|
|
const panels = [];
|
|
let current = "";
|
|
for (const sentence of sentences.map((entry) => entry.trim()).filter(Boolean)) {
|
|
const candidate = current ? `${current} ${sentence}` : sentence;
|
|
if (candidate.length > 320 && current) {
|
|
panels.push(current);
|
|
current = sentence;
|
|
} else {
|
|
current = candidate;
|
|
}
|
|
}
|
|
if (current) {
|
|
panels.push(current);
|
|
}
|
|
return panels.length ? panels : [text];
|
|
}
|
|
|
|
function renderList(items) {
|
|
const list = Array.isArray(items) ? items : [items];
|
|
const cleaned = list.map((item) => cleanSpeech(item)).filter(Boolean);
|
|
return cleaned.length ? cleaned.map((item) => `- ${item}`).join("\n") : "- No specific counterargument assigned; choose the most natural reader objection for this moment.";
|
|
}
|
|
|
|
function formatChoiceLabel(displayName, value) {
|
|
const label = sanitizeChoiceLabel(value);
|
|
const withoutName = label.replace(new RegExp(`^${escapeRegExp(displayName)}\\s*:\\s*`, "i"), "");
|
|
return sanitizeChoiceLabel(`${displayName}: ${withoutName}`);
|
|
}
|
|
|
|
function summarizeChoice(value) {
|
|
const sentences = cleanSpeech(value)
|
|
.replace(/^["']|["']$/g, "")
|
|
.split(/[.?!]/)[0]
|
|
.trim();
|
|
if (/^(good|right|yes|exactly|hold that answer)\b/i.test(sentences)) {
|
|
return "Bring this back to the lesson";
|
|
}
|
|
return sentences.slice(0, 96) || "Bring this back to the lesson";
|
|
}
|
|
|
|
function sanitizeChoiceLabel(value) {
|
|
return cleanSpeech(value)
|
|
.replace(/[\[\]\{\}\n\r]/g, " ")
|
|
.replace(/\s+/g, " ")
|
|
.trim()
|
|
.slice(0, 140) || "Someone answers Void";
|
|
}
|
|
|
|
function quoteInk(value) {
|
|
const cleaned = cleanSpeech(value).replace(/"/g, '\\"');
|
|
return `"${cleaned}"`;
|
|
}
|
|
|
|
function cleanSpeech(value) {
|
|
return normalizeAscii(String(value ?? ""))
|
|
.replace(/\r?\n+/g, " ")
|
|
.replace(/\s+/g, " ")
|
|
.trim();
|
|
}
|
|
|
|
function cleanSpeakerPrefix(value, speaker) {
|
|
const cleaned = cleanSpeech(value)
|
|
.replace(/^["']|["']$/g, "")
|
|
.trim();
|
|
return cleaned.replace(new RegExp(`^(?:${escapeRegExp(speaker)}|Void)\\s*(?:says\\s*)?:\\s*`, "i"), "").trim();
|
|
}
|
|
|
|
function escapeRegExp(value) {
|
|
return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
|
|
function normalizeAscii(value) {
|
|
return value
|
|
.replace(/[\u2018\u2019]/g, "'")
|
|
.replace(/[\u201C\u201D]/g, '"')
|
|
.replace(/\u2014/g, "--")
|
|
.replace(/\u2013/g, "-")
|
|
.replace(/\u2026/g, "...");
|
|
}
|
|
|
|
function renderTranscript(entries) {
|
|
if (!entries.length) {
|
|
return "- No prior branch dialogue.";
|
|
}
|
|
return entries.map((entry) => `- ${entry.speaker}: ${entry.text}`).join("\n");
|
|
}
|
|
|
|
function parseFaceResponse(text, actor) {
|
|
const choiceLabel = section(text, "CHOICE LABEL") || "";
|
|
const speech = section(text, "SPOKEN RESPONSE") || "";
|
|
const privateNote = section(text, "PRIVATE NOTE") || "";
|
|
return {
|
|
choiceLabel: cleanSpeech(choiceLabel),
|
|
speech: cleanSpeech(speech),
|
|
privateNote: cleanSpeech(privateNote),
|
|
};
|
|
}
|
|
|
|
function parseArticleInterpreterOutput(text) {
|
|
const cleaned = text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");
|
|
try {
|
|
const parsed = JSON.parse(cleaned);
|
|
return {
|
|
choiceLabel: cleanSpeech(parsed.choice_label ?? parsed.choiceLabel ?? ""),
|
|
speech: cleanSpeech(parsed.speech ?? ""),
|
|
privateNote: cleanSpeech(parsed.private_note ?? parsed.privateNote ?? ""),
|
|
};
|
|
} catch {
|
|
return {
|
|
choiceLabel: section(text, "choice_label") || section(text, "CHOICE LABEL") || "",
|
|
speech: section(text, "speech") || section(text, "SPOKEN RESPONSE") || cleanSpeech(text),
|
|
privateNote: section(text, "private_note") || section(text, "PRIVATE NOTE") || "",
|
|
};
|
|
}
|
|
}
|
|
|
|
function localArticleInterpretation(parsedFace, faceText, actor) {
|
|
const displayName = actor.displayName ?? actor.identityId;
|
|
const speech = cleanSpeakerPrefix(parsedFace.speech || faceText, displayName);
|
|
const choiceLabel = formatChoiceLabel(displayName, parsedFace.choiceLabel || speech);
|
|
return {
|
|
choiceLabel,
|
|
speech,
|
|
privateNote: parsedFace.privateNote || "Local article interpreter preserved the strict Face response shape.",
|
|
};
|
|
}
|
|
|
|
function section(text, label) {
|
|
const pattern = new RegExp(`${label}:\\s*([\\s\\S]*?)(?=\\n[A-Z][A-Z ]+:|$)`, "i");
|
|
return text.match(pattern)?.[1]?.trim();
|
|
}
|
|
|
|
function parseInterpreterOutput(text) {
|
|
const decision = text.match(/decision:\s*(route|retry|drop)/i)?.[1]?.toLowerCase();
|
|
return {
|
|
decision,
|
|
blocks: parseDslBlocks(text),
|
|
};
|
|
}
|
|
|
|
function parseDslBlocks(text) {
|
|
const lines = text.split(/\r?\n/);
|
|
const blocks = [];
|
|
for (let index = 0; index < lines.length; index += 1) {
|
|
const kind = ["STATE NOTE", "SAY", "ARTICLE", "BIFROST TOPIC"].includes(lines[index].trim().toUpperCase())
|
|
? lines[index].trim().toUpperCase()
|
|
: undefined;
|
|
if (!kind) {
|
|
continue;
|
|
}
|
|
const body = [];
|
|
index += 1;
|
|
while (index < lines.length && lines[index].trim() !== "END") {
|
|
body.push(lines[index]);
|
|
index += 1;
|
|
}
|
|
blocks.push({ kind, fields: parseDslFields(body) });
|
|
}
|
|
return blocks;
|
|
}
|
|
|
|
function parseDslFields(lines) {
|
|
const fields = {};
|
|
let key;
|
|
let value = [];
|
|
const flush = () => {
|
|
if (key) {
|
|
fields[key] = value.join("\n").trim();
|
|
}
|
|
};
|
|
for (const line of lines) {
|
|
const match = line.match(/^([A-Za-z][A-Za-z0-9_]*):\s*(.*)$/);
|
|
if (match) {
|
|
flush();
|
|
key = match[1];
|
|
const inlineValue = match[2].trim();
|
|
value = inlineValue && inlineValue !== "|" && inlineValue !== ">" ? [match[2]] : [];
|
|
continue;
|
|
}
|
|
if (key) {
|
|
value.push(line.replace(/^\s{2}/, ""));
|
|
}
|
|
}
|
|
flush();
|
|
return fields;
|
|
}
|
|
|
|
function runCodex(prompt, input) {
|
|
return new Promise((resolveRun) => {
|
|
const started = Date.now();
|
|
const args = [
|
|
...splitArgs(process.env.CODEX_EXEC_ARGS ?? ""),
|
|
"exec",
|
|
"-m",
|
|
input.model,
|
|
"-c",
|
|
'approval_policy="never"',
|
|
"-c",
|
|
`model_reasoning_effort=${JSON.stringify(input.reasoningEffort)}`,
|
|
"--json",
|
|
"--skip-git-repo-check",
|
|
"-s",
|
|
"read-only",
|
|
"-",
|
|
];
|
|
if (input.mcpMode === "real-readonly") {
|
|
args.splice(
|
|
args.indexOf("--json"),
|
|
0,
|
|
"-c",
|
|
`mcp_servers.voidbot.env.VOIDBOT_MCP_TOOL_ALLOWLIST=${JSON.stringify(retrievalToolAllowlist)}`,
|
|
);
|
|
}
|
|
const child = spawn(process.env.CODEX_EXECUTABLE ?? "codex", args, {
|
|
cwd: repoRoot,
|
|
env: process.env,
|
|
stdio: ["pipe", "pipe", "pipe"],
|
|
windowsHide: true,
|
|
});
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.setEncoding("utf8");
|
|
child.stderr.setEncoding("utf8");
|
|
child.stdout.on("data", (chunk) => {
|
|
stdout += chunk;
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
stderr += chunk;
|
|
});
|
|
child.stdin.end(prompt);
|
|
const timer = setTimeout(() => child.kill(), input.timeoutMs);
|
|
child.on("close", (code, signal) => {
|
|
clearTimeout(timer);
|
|
resolveRun({ code, signal, durationMs: Date.now() - started, stdout, stderr });
|
|
});
|
|
});
|
|
}
|
|
|
|
function runProcess(command, args, options) {
|
|
return new Promise((resolveRun, reject) => {
|
|
const child = spawn(command, args, {
|
|
cwd: options.cwd,
|
|
env: process.env,
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
windowsHide: true,
|
|
});
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.setEncoding("utf8");
|
|
child.stderr.setEncoding("utf8");
|
|
child.stdout.on("data", (chunk) => {
|
|
stdout += chunk;
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
stderr += chunk;
|
|
});
|
|
const timer = setTimeout(() => child.kill(), options.timeoutMs);
|
|
child.on("close", (code, signal) => {
|
|
clearTimeout(timer);
|
|
if (code === 0) {
|
|
resolveRun({ code, signal, stdout, stderr });
|
|
} else {
|
|
reject(new Error(`${command} ${args.join(" ")} failed with ${code ?? signal}\n${stderr}\n${stdout}`));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function parseJsonEvents(stdout) {
|
|
return stdout
|
|
.split(/\r?\n/)
|
|
.filter(Boolean)
|
|
.map((line) => {
|
|
try {
|
|
return JSON.parse(line);
|
|
} catch {
|
|
return undefined;
|
|
}
|
|
})
|
|
.filter(Boolean);
|
|
}
|
|
|
|
function extractFinalText(events, stdout) {
|
|
const messages = events
|
|
.filter((event) => event.type === "item.completed" && event.item?.type === "agent_message")
|
|
.map((event) => String(event.item.text ?? "").trim())
|
|
.filter(Boolean);
|
|
return messages.at(-1) ?? stdout.trim();
|
|
}
|
|
|
|
function renderTemplate(name, variables) {
|
|
let template = readFileSync(resolve(promptsRoot, name), "utf8");
|
|
for (const [key, value] of Object.entries(variables)) {
|
|
template = template.replaceAll(`{{${key}}}`, String(value ?? ""));
|
|
}
|
|
return template;
|
|
}
|
|
|
|
async function loadGlobalAgentDoctrine() {
|
|
const candidates = [
|
|
process.env.CODEX_HOME ? resolve(process.env.CODEX_HOME, "AGENTS.md") : undefined,
|
|
process.env.USERPROFILE ? resolve(process.env.USERPROFILE, ".codex", "AGENTS.md") : undefined,
|
|
resolve(homedir(), ".codex", "AGENTS.md"),
|
|
].filter(Boolean);
|
|
for (const candidate of [...new Set(candidates)]) {
|
|
try {
|
|
const content = await readFile(candidate, "utf8");
|
|
if (content.trim()) {
|
|
return content.trim();
|
|
}
|
|
} catch {
|
|
// Try the next known global doctrine path.
|
|
}
|
|
}
|
|
return "# Global Agent Instructions Unavailable\n\nNo readable global AGENTS.md file was found.";
|
|
}
|
|
|
|
function splitArgs(value) {
|
|
return value.match(/(?:[^\s"]+|"[^"]*")+/g)?.map((entry) => entry.replace(/^"|"$/g, "")) ?? [];
|
|
}
|
|
|
|
function parseArgs(args) {
|
|
const options = {};
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index];
|
|
if (!arg.startsWith("--")) {
|
|
continue;
|
|
}
|
|
const key = arg.slice(2);
|
|
const next = args[index + 1];
|
|
if (!next || next.startsWith("--")) {
|
|
options[key] = true;
|
|
continue;
|
|
}
|
|
options[key] = next;
|
|
index += 1;
|
|
}
|
|
return options;
|
|
}
|
|
|
|
function numberOption(value, fallback) {
|
|
const parsed = Number(value);
|
|
return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
|
|
}
|
|
|
|
function toInkCommentPath(path) {
|
|
return path.replace(/\\/g, "/");
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(error);
|
|
process.exit(1);
|
|
});
|