@vigolium/piolium 0.0.1

package/extensions/piolium/modes/revisit.ts

@@ -0,0 +1,279 @@
+/**
+ * Revisit mode (`/piolium-revisit`).
+ *
+ * Second-or-Nth pass over a completed audit, anti-anchored, reusing durable
+ * `piolium/attack-surface/` context (command-defs/revisit.md, archon-audit
+ * @ 2026-05-16). Ten phases (byte-identical upstream ids 0–9):
+ *
+ *   0 Intent Cartography                (intent-mapper; soft signal)
+ *   1 Deep Probe (fresh, anti-anchored) (probe-lead)
+ *   2 Enrichment Re-classify            (inline, no agent)
+ *   3 Review Chambers (anti-anchored)   (review-adjudicator)
+ *   4 FP Check                          (independent-verifier)
+ *   5 Variant Analysis (new findings)   (variant-scanner)
+ *   6 Variant Analysis (round-1 C/H)    (variant-scanner)
+ *   7 PoC Construction (new findings)   (poc-author)
+ *   8 Finding Finalization              (finding-writer)
+ *   9 Final Report Regeneration         (report-composer)
+ *
+ * MVP: each phase is a single agent run with anti-anchoring instructions
+ * folded into the task prompt. Phase 0's failure is non-blocking.
+ */
+
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentRuntimeModel } from "../agent-runner.ts";
+import { loadAgents } from "../agents.ts";
+import {
+	type AuditRunState,
+	applyPhaseStatus,
+	initAudit,
+	latestAudit,
+	markAuditStatus,
+	readAuditState,
+} from "../audit-state.ts";
+import { runCandidateScanAsync } from "../candidate-scan.ts";
+import { listFindingDirs, promoteDraftsByPrefix } from "../findings.ts";
+import { runReconAsync } from "../recon.ts";
+import { type PhaseUiHooks, runAgentPhase } from "./phase-runner.ts";
+
+export interface RunRevisitOptions {
+	cwd: string;
+	signal?: AbortSignal;
+	ui?: PhaseUiHooks;
+	forceFresh?: boolean;
+	agentRuntime?: AgentRuntimeModel;
+}
+
+export interface RunRevisitResult {
+	auditId: string;
+	status: "complete" | "failed";
+	phases: Record<string, "complete" | "failed" | "skipped">;
+}
+
+const ATTACK_SURFACE_DIR = "piolium/attack-surface";
+const REVISIT_TMP_DIR = "piolium/tmp/piolium/revisit";
+export const REVISIT_INTENT_CORPUS = `${ATTACK_SURFACE_DIR}/intent-corpus.json`;
+export const REVISIT_ATTACK_SURFACE_INVENTORY = `${ATTACK_SURFACE_DIR}/revisit-attack-surface-inventory.md`;
+export const REVISIT_PROBE_SUMMARY = `${ATTACK_SURFACE_DIR}/revisit-probe-summary.md`;
+export const REVISIT_CHAMBER_SUMMARY = `${ATTACK_SURFACE_DIR}/revisit-chamber-summary.md`;
+
+const REVISIT_PHASES = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"] as const;
+type RevisitPhase = (typeof REVISIT_PHASES)[number];
+
+function exists(cwd: string, rel: string): boolean {
+	return existsSync(join(cwd, rel));
+}
+
+function pickResume(cwd: string, force: boolean): AuditRunState | undefined {
+	if (force) return undefined;
+	const state = readAuditState(cwd).state;
+	const audit = state ? latestAudit(state) : undefined;
+	if (!audit) return undefined;
+	if (audit.mode !== "revisit") return undefined;
+	if (audit.status === "complete") return undefined;
+	return audit;
+}
+
+const ANTI_ANCHOR_PREAMBLE = [
+	"REVISIT MODE — anti-anchoring rules:",
+	"  - Do NOT reuse prior conclusions. Treat existing findings/ as a NEGATIVE LIST: do not re-surface them.",
+	"  - Re-derive hypotheses from primary sources (code, advisories, KB) — don't copy from prior reports.",
+	"  - Severity should be re-assessed independently.",
+].join("\n");
+
+function priorFindingNegatives(cwd: string): string {
+	const dirs = listFindingDirs(cwd);
+	if (dirs.length === 0) return "(no prior findings recorded)";
+	return dirs.map((d) => `  - ${d.id} ${d.slug}`).join("\n");
+}
+
+function buildTask(phase: RevisitPhase, cwd: string): string {
+	const negatives = priorFindingNegatives(cwd);
+	switch (phase) {
+		case "0":
+			return [
+				"Run Phase 0 (Intent Cartography) of /piolium-revisit.",
+				"Scan the target repository for documented security intent: SECURITY.md, README security sections, docs/security/, threat-model files, inline `#security:` / `// security:` pragmas.",
+				"Produce a structured corpus with two lists: `intentional_behaviors[]` (project-declared safe-by-design behaviors) and `acknowledged_risks[]` (vuln classes the project explicitly considers in scope).",
+				`Output: \`${REVISIT_INTENT_CORPUS}\`. Always overwrite — rebuilt per revisit round so doc changes between rounds are reflected.`,
+				"Build the corpus only — no findings cross-check (unlike confirm V1.5).",
+				"If the repo has no security docs, write an empty `{intentional_behaviors: [], acknowledged_risks: []}` corpus.",
+				"The corpus is a SOFT priority hint — never a gate.",
+			].join("\n");
+		case "1":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"",
+				"Run Phase 1 (Deep Probe — fresh teams, anti-anchored) for /piolium-revisit.",
+				"Negative list (do NOT re-surface):",
+				negatives,
+				`Read the durable prior attack-surface corpus from \`${ATTACK_SURFACE_DIR}/\` (candidates-summary.md, candidates.jsonl, KB, route/authz matrix, source/sink flows, probe summary, cross-service edges).`,
+				`Write updated reusable attack-surface inventory to \`${REVISIT_ATTACK_SURFACE_INVENTORY}\`.`,
+				`Write the probe execution summary to \`${REVISIT_PROBE_SUMMARY}\`.`,
+				`Transient workspace, if needed: ${REVISIT_TMP_DIR}/r1/.`,
+				"Drafts: piolium/findings-draft/r1-NNN-<slug>.md",
+			].join("\n");
+		case "2":
+			return "Phase 2 (Enrichment Re-classify) runs inline (no agent).";
+		case "3":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 3 (Review Chambers — fresh, anti-anchored) for /piolium-revisit.",
+				"Negative list:",
+				negatives,
+				`Read \`${ATTACK_SURFACE_DIR}/\` first so chamber decisions reference current candidate files, routes, sources, sinks, and trust boundaries.`,
+				`Transient workspace: ${REVISIT_TMP_DIR}/r3/`,
+				`Durable chamber summary: ${REVISIT_CHAMBER_SUMMARY}`,
+				"Surviving drafts: piolium/findings-draft/r3-NNN-<slug>.md",
+			].join("\n");
+		case "4":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 4 (FP Check) on every revisit-stage draft. Cold re-verification of CRITICAL/HIGH survivors; reject anything weakly grounded.",
+			].join("\n");
+		case "5":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 5 (Variant Analysis — new round findings). Drafts: piolium/findings-draft/r5-NNN-<slug>.md",
+			].join("\n");
+		case "6":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 6 (Variant Analysis on Round-1 CRIT/HIGH). Re-hunt variants of the highest-severity round-1 findings with fresh priors. Drafts: piolium/findings-draft/r6-NNN-<slug>.md",
+			].join("\n");
+		case "7":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 7 (PoC Construction — new findings only). Build PoCs and evidence for revisit-stage findings.",
+			].join("\n");
+		case "8":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 8 (Finding Finalization) on revisit-stage findings — author report.md per finding.",
+			].join("\n");
+		case "9":
+			return [
+				ANTI_ANCHOR_PREAMBLE,
+				"Run Phase 9 (Final Report Regeneration). Merge round-1 + round-N findings into piolium/final-audit-report.md and append a `## Discoveries by Round` section describing what each round added.",
+			].join("\n");
+		default:
+			return `Unknown revisit phase: ${phase}`;
+	}
+}
+
+function gateFor(phase: RevisitPhase, cwd: string): () => boolean {
+	switch (phase) {
+		case "0":
+			return () => exists(cwd, REVISIT_INTENT_CORPUS);
+		case "1":
+			return () => exists(cwd, REVISIT_PROBE_SUMMARY);
+		case "3":
+			return () => exists(cwd, REVISIT_CHAMBER_SUMMARY);
+		case "9":
+			return () => {
+				const path = join(cwd, "piolium/final-audit-report.md");
+				if (!existsSync(path)) return false;
+				return readFileSync(path, "utf8").includes("Discoveries by Round");
+			};
+		default:
+			return () => true;
+	}
+}
+
+export async function runRevisitAudit(opts: RunRevisitOptions): Promise<RunRevisitResult> {
+	const { cwd, signal, ui } = opts;
+	ui?.setStatus?.("piolium-revisit", "● preparing recon");
+	const recon = await runReconAsync(cwd, { signal });
+	mkdirSync(join(cwd, ATTACK_SURFACE_DIR), { recursive: true });
+	ui?.setStatus?.("piolium-revisit", "● scanning candidate files");
+	const candidateScan = await runCandidateScanAsync(cwd, { signal });
+	ui?.notify?.(
+		`Candidate scan: ${candidateScan.candidateCount} match(es) across ${candidateScan.candidateFiles} file(s).`,
+		"info",
+	);
+	mkdirSync(join(cwd, REVISIT_TMP_DIR), { recursive: true });
+	let audit = pickResume(cwd, opts.forceFresh ?? false);
+	if (!audit) {
+		audit = await initAudit(cwd, {
+			mode: "revisit",
+			...(recon.commit ? { commit: recon.commit } : { commit: null }),
+			...(recon.branch ? { branch: recon.branch } : { branch: "nogit" }),
+			...(recon.repository ? { repository: recon.repository } : {}),
+			history_available: recon.historyAvailable,
+			agent_sdk: "pi",
+		});
+	}
+
+	const { agents } = loadAgents({ cwd });
+	const phaseAgents: Record<RevisitPhase, ReturnType<typeof agents.get>> = {
+		"0": agents.get("intent-mapper"),
+		"1": agents.get("probe-lead"),
+		"2": undefined,
+		"3": agents.get("review-adjudicator"),
+		"4": agents.get("independent-verifier"),
+		"5": agents.get("variant-scanner"),
+		"6": agents.get("variant-scanner"),
+		"7": agents.get("poc-author"),
+		"8": agents.get("finding-writer"),
+		"9": agents.get("report-composer"),
+	};
+
+	let failed = false;
+	for (const name of REVISIT_PHASES) {
+		// Phase 2 (Enrichment Re-classify) has no upstream agent — it is a
+		// deterministic inline reclassification step. Mark it complete.
+		if (name === "2") {
+			await applyPhaseStatus(cwd, audit, name, { status: "complete" });
+			continue;
+		}
+		try {
+			await runAgentPhase({
+				cwd,
+				audit,
+				phaseName: name,
+				statusKey: "piolium-revisit",
+				statusLabel: `● R${name}`,
+				agent: phaseAgents[name],
+				missingAgentMessage: `agent missing for revisit phase ${name}`,
+				task: buildTask(name, cwd),
+				gate: gateFor(name, cwd),
+				mode: "revisit",
+				ui,
+				agentRuntime: opts.agentRuntime,
+				...(signal ? { signal } : {}),
+			});
+			// Promote drafts surfaced in chamber + variant rounds.
+			if (name === "3") promoteDraftsByPrefix(cwd, "r3-");
+			if (name === "5") promoteDraftsByPrefix(cwd, "r5-");
+			if (name === "6") promoteDraftsByPrefix(cwd, "r6-");
+		} catch {
+			// Phase 0 (intent cartography) is a soft signal — non-blocking.
+			if (name === "0") {
+				ui?.notify?.(
+					"Revisit phase 0 (intent cartography) failed; continuing without the corpus.",
+					"warning",
+				);
+				await applyPhaseStatus(cwd, audit, name, {
+					status: "failed",
+					error: "policy: skip-and-continue",
+				});
+				continue;
+			}
+			failed = true;
+			break;
+		}
+	}
+
+	await markAuditStatus(cwd, audit.audit_id, failed ? "failed" : "complete");
+	const fresh =
+		readAuditState(cwd).state?.audits.find((a) => a.audit_id === audit.audit_id) ?? audit;
+	const phases: Record<string, "complete" | "failed" | "skipped"> = {};
+	for (const [name, p] of Object.entries(fresh.phases)) {
+		if (p.status === "complete" || p.status === "failed" || p.status === "skipped") {
+			phases[name] = p.status;
+		}
+	}
+	ui?.notify?.(failed ? "Revisit failed." : "Revisit complete.", failed ? "error" : "info");
+	return { auditId: audit.audit_id, status: failed ? "failed" : "complete", phases };
+}

package/extensions/piolium/modes.ts

@@ -0,0 +1,48 @@
+/**
+ * Mode → phase list registry.
+ *
+ * Phase keys are byte-identical to upstream archon-audit's
+ * `command-defs/*.md` frontmatter `phases[].id`, so `audit-state.json`
+ * files written by piolium stay schema-compatible with files produced by
+ * the upstream Claude/Codex archon-audit plugins. User-facing output renders
+ * these keys as ordered stage labels via phase-labels.ts (which is
+ * mode-aware because revisit/longshot/reinvest/diff reuse bare numeric ids).
+ *
+ * Synced from archon-audit @ 2026-05-16 (commits e40313f / 0ebff33 /
+ * c7ab09c): the upstream refactor renumbered every mode and renamed every
+ * sub-agent. piolium's older private phase keys (the L#, P#, Q#, V7 family)
+ * and their tail cleanup phases were dropped to match upstream exactly;
+ * upstream folds
+ * file-state stamping + post-audit cleanup inline into each mode's final
+ * phase.
+ *
+ * Source citations (command-defs/*.md):
+ *   - lite:     L1 recon → [L2 secrets ‖ L3 fast SAST]
+ *   - balanced: B1 → B2 → [B3 ‖ B4] → B5 → B6 intent → B7 PoC → B8 → B9
+ *   - deep:     [D1 ‖ D2] → D3 → D4 → [D5 ‖ D7] → D6 → D8 → D9 → D10 intent
+ *               → D11 → D12 → D13 → D14
+ *   - confirm:  V1 → V1.5 intent → V2 → V3 → V4 → V5 → V6
+ *   - revisit:  0 intent → 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9
+ *   - merge:    M1 → M2 → M3 → M4 → M5 → M6 → M7 (workspace-only)
+ *   - longshot: 1 enumerate → 2 hunt fan-out → 3 aggregate
+ *   - reinvest: 1 enumerate → 2 cross-verifier fan-out → 3 consensus
+ *   - diff:     1 diff-based phase selection (re-runs deep phases)
+ */
+
+import type { AuditMode } from "./audit-state.ts";
+
+export const MODE_PHASES: Record<AuditMode, readonly string[]> = {
+	lite: ["L1", "L2", "L3"],
+	balanced: ["B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"],
+	deep: ["D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "D10", "D11", "D12", "D13", "D14"],
+	diff: ["1"],
+	confirm: ["V1", "V1.5", "V2", "V3", "V4", "V5", "V6"],
+	revisit: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+	merge: ["M1", "M2", "M3", "M4", "M5", "M6", "M7"],
+	longshot: ["1", "2", "3"],
+	reinvest: ["1", "2", "3"],
+};
+
+export function phasesFor(mode: AuditMode): readonly string[] {
+	return MODE_PHASES[mode];
+}

package/extensions/piolium/phase-labels.ts

@@ -0,0 +1,123 @@
+/**
+ * Per-mode phase display labels.
+ *
+ * Phase keys are byte-identical to upstream archon-audit's
+ * `command-defs/*.md` frontmatter `phases[].id` so `audit-state.json` files
+ * stay schema-compatible with the upstream Claude/Codex plugins. Several
+ * modes (revisit, longshot, reinvest, diff) reuse bare numeric ids
+ * (`"1"`, `"2"`, …), so labels MUST be looked up per mode — a flat map
+ * would collide (`longshot:"1"` = "Enumerate Targets" vs
+ * `reinvest:"1"` = "Enumerate Findings").
+ */
+
+import type { AuditMode } from "./audit-state.ts";
+
+const PHASE_LABELS: Record<AuditMode, Record<string, string>> = {
+	lite: {
+		L1: "Recon Sweep",
+		L2: "Secrets Scan",
+		L3: "Fast Code Scan",
+	},
+	balanced: {
+		B1: "Intel Sweep",
+		B2: "Threat Model",
+		B3: "Code Scan",
+		B4: "Targeted Probe",
+		B5: "Review Panel",
+		B6: "Intent Reconciliation",
+		B7: "PoC Authoring",
+		B8: "Finding Finalize",
+		B9: "Report Compose",
+	},
+	deep: {
+		D1: "Intel Sweep (CVE)",
+		D2: "Intel Sweep (History)",
+		D3: "Patch Audit",
+		D4: "Threat Model",
+		D5: "Code Scan",
+		D6: "Deep Probe",
+		D7: "Access Audit",
+		D8: "Taint Trace",
+		D9: "Review Panel",
+		D10: "Intent Reconciliation",
+		D11: "Variant Sweep",
+		D12: "PoC Authoring",
+		D13: "Finding Finalize",
+		D14: "Report Compose",
+	},
+	confirm: {
+		V1: "Findings Inventory",
+		"V1.5": "Intent Cross-Check",
+		V2: "Environment Discovery",
+		V3: "Environment Provisioning",
+		V4: "PoC Execution",
+		V5: "Test-Based Fallback",
+		V6: "Confirmation Report",
+	},
+	revisit: {
+		"0": "Intent Cartography",
+		"1": "Deep Probe (fresh, anti-anchored)",
+		"2": "Enrichment Re-classify",
+		"3": "Review Chambers (fresh, anti-anchored)",
+		"4": "FP Check",
+		"5": "Variant Analysis (new findings)",
+		"6": "Variant Analysis (round-1 CRIT/HIGH)",
+		"7": "PoC Construction (new findings)",
+		"8": "Finding Finalization",
+		"9": "Final Report Regeneration",
+	},
+	merge: {
+		M1: "Validate Every Finding",
+		M2: "Semantic Dedup by Root Cause",
+		M3: "Auto-Fix Safe Issues",
+		M4: "Quarantine Unfixable",
+		M5: "Renumber + Rebuild References",
+		M6: "Regenerate Summaries",
+		M7: "Cleanup + Merge Report",
+	},
+	longshot: {
+		"1": "Enumerate Targets",
+		"2": "Hunt (file-by-file fan-out)",
+		"3": "Aggregate & Deduplicate",
+	},
+	reinvest: {
+		"1": "Enumerate Findings",
+		"2": "Fan Out Wave-Verifier",
+		"3": "Consensus Summary",
+	},
+	diff: {
+		"1": "Diff-based Phase Selection",
+	},
+};
+
+function basePhaseId(phase: string): string {
+	return phase.split(":")[0] ?? phase;
+}
+
+function orderNumber(index: number, total: number, minWidth = 1): string {
+	const width = Math.max(minWidth, total >= 10 ? 2 : 1);
+	return String(index + 1).padStart(width, "0");
+}
+
+export function phaseLabel(mode: AuditMode, phase: string): string {
+	const map = PHASE_LABELS[mode] ?? {};
+	return map[phase] ?? map[basePhaseId(phase)] ?? "Phase";
+}
+
+export function formatPhaseListLabel(
+	mode: AuditMode,
+	phase: string,
+	index: number,
+	total: number,
+): string {
+	return `${orderNumber(index, total)}. ${phaseLabel(mode, phase)}`;
+}
+
+export function formatPhaseDetailLabel(
+	mode: AuditMode,
+	phase: string,
+	index: number,
+	total: number,
+): string {
+	return `${formatPhaseListLabel(mode, phase, index, total)} (${phase})`;
+}

package/extensions/piolium/phase-status-strip.ts

@@ -0,0 +1,92 @@
+import type { AuditMode, PhaseState, PhaseStatus } from "./audit-state.ts";
+import { formatPhaseListLabel } from "./phase-labels.ts";
+
+export interface PhaseStatusTheme {
+	fg(color: string, text: string): string;
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Find the first phase token present in a status string. The matcher is
+ * built from the mode's actual phase list (longest id first so `D14` wins
+ * over `D1`, `V1.5` over `V1`), which keeps it correct for the bare numeric
+ * ids used by revisit/longshot/reinvest/diff without a hardcoded prefix
+ * regex.
+ */
+export function extractStatusPhase(
+	text: string | undefined,
+	phases: readonly string[],
+): string | undefined {
+	if (!text || phases.length === 0) return undefined;
+	const ordered = [...phases].sort((a, b) => b.length - a.length).map(escapeRegExp);
+	const matcher = new RegExp(`(?<![\\w.])(${ordered.join("|")})(?![\\w.])`, "g");
+	for (const match of text.matchAll(matcher)) {
+		const phase = match[1];
+		if (phase && phases.includes(phase)) return phase;
+	}
+	return undefined;
+}
+
+export function renderPhaseStatusStrip(
+	mode: AuditMode,
+	phases: readonly string[],
+	phaseStates: Record<string, PhaseState>,
+	currentPhase: string | undefined,
+	theme: PhaseStatusTheme,
+): string {
+	void mode;
+	return phases
+		.map((phase) => {
+			const status = phaseStates[phase]?.status ?? "pending";
+			return formatPhaseToken(phase, status, currentPhase === phase, theme);
+		})
+		.join(" ");
+}
+
+export function renderPhaseStatusList(
+	mode: AuditMode,
+	phases: readonly string[],
+	phaseStates: Record<string, PhaseState>,
+	currentPhase: string | undefined,
+	theme: PhaseStatusTheme,
+): string[] {
+	return phases.map((phase, index) => {
+		const status = phaseStates[phase]?.status ?? "pending";
+		const marker = phaseMarker(status, currentPhase === phase);
+		const label = formatPhaseListLabel(mode, phase, index, phases.length);
+		const text = `• ${marker} ${label}`;
+		return theme.fg(phaseColor(status, currentPhase === phase), text);
+	});
+}
+
+function formatPhaseToken(
+	phase: string,
+	status: PhaseStatus,
+	isCurrent: boolean,
+	theme: PhaseStatusTheme,
+): string {
+	if (status === "complete") return theme.fg("success", `✓${phase}`);
+	if (status === "failed") return theme.fg("error", `✗${phase}`);
+	if (status === "skipped") return theme.fg("warning", `↷${phase}`);
+	if (status === "in_progress" || isCurrent) return theme.fg("accent", `●${phase}`);
+	return theme.fg("dim", `·${phase}`);
+}
+
+function phaseMarker(status: PhaseStatus, isCurrent: boolean): string {
+	if (status === "complete") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "skipped") return "↷";
+	if (status === "in_progress" || isCurrent) return "●";
+	return "·";
+}
+
+function phaseColor(status: PhaseStatus, isCurrent: boolean): string {
+	if (status === "complete") return "success";
+	if (status === "failed") return "error";
+	if (status === "skipped") return "warning";
+	if (status === "in_progress" || isCurrent) return "accent";
+	return "dim";
+}

package/extensions/piolium/prompt-prefix-editor.ts

@@ -0,0 +1,39 @@
+import { CustomEditor, type KeybindingsManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { type EditorTheme, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+export const ARCHON_SRCERY_THEME_NAME = "piolium-srcery";
+export const ARCHON_PROMPT_PREFIX = "piolium-audit ▶ ";
+export const ARCHON_PROMPT_PREFIX_GREEN = "\x1b[38;2;152;188;55m";
+const RESET_FOREGROUND = "\x1b[39m";
+
+export function shouldUseArchonPromptPrefix(theme: Pick<Theme, "name">): boolean {
+	return theme.name === ARCHON_SRCERY_THEME_NAME;
+}
+
+export class ArchonPromptPrefixEditor extends CustomEditor {
+	private readonly prefixWidth = visibleWidth(ARCHON_PROMPT_PREFIX);
+
+	constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
+		super(tui, theme, keybindings, { paddingX: visibleWidth(ARCHON_PROMPT_PREFIX) });
+	}
+
+	override render(width: number): string[] {
+		const lines = super.render(width);
+		if (lines.length < 3) return lines;
+
+		const renderedPrefixWidth = Math.min(this.prefixWidth, Math.max(0, Math.floor((width - 1) / 2)));
+		if (renderedPrefixWidth <= 0) return lines;
+
+		const plainPrefix = truncateToWidth(ARCHON_PROMPT_PREFIX, renderedPrefixWidth, "");
+		if (!plainPrefix) return lines;
+
+		const expectedPadding = " ".repeat(renderedPrefixWidth);
+		const promptLine = lines[1] ?? "";
+		const styledPrefix = `${ARCHON_PROMPT_PREFIX_GREEN}${plainPrefix}${RESET_FOREGROUND}`;
+		lines[1] = promptLine.startsWith(expectedPadding)
+			? `${styledPrefix}${promptLine.slice(renderedPrefixWidth)}`
+			: truncateToWidth(`${styledPrefix}${promptLine}`, width);
+
+		return lines;
+	}
+}