@gillcash/necktie 0.5.2 → 0.6.0

package/.opencode/plugins/necktie.mjs

@@ -1,14 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import { parseCommandFile } from "./necktie-frontmatter.cjs";
+import { resolveMode } from "../../lib/necktie-policy.cjs";
+import { buildContext, executeModeCommand, parseModeArguments } from "../../lib/necktie-command.cjs";
+import { readSessionMode, sessionIdentifier, writeSessionMode } from "../../lib/necktie-session.cjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const { parseCommandFile } = require("./necktie-frontmatter.cjs");
-const { buildInstructions, resolveMode, writeDefaultMode } = require("../../lib/necktie-policy.cjs");
-const { USAGE, formatStatus, parseModeArguments } = require("../../lib/necktie-command.cjs");
-const { readSessionMode, sessionIdentifier, writeSessionMode } = require("../../lib/necktie-session.cjs");
 
 const root = path.resolve(__dirname, "../..");
 const skillsDir = path.join(root, "skills");
@@ -24,35 +22,11 @@ export function activeMode(input = {}) {
 }
 
 export function handleModeCommand(input = {}) {
-  const parsed = parseModeArguments(input.arguments);
-  if (parsed.type === "invalid") return parsed.usage || USAGE;
   const key = sessionKey(input);
-  let stored = readSessionMode("opencode", key);
-
-  if (parsed.type === "set-session") {
-    try {
-      writeSessionMode("opencode", key, parsed.mode);
-      return `Necktie mode set to ${parsed.mode} for this session.`;
-    } catch (error) {
-      return `Failed to save Necktie session mode: ${error.message}`;
-    }
-  }
-  if (parsed.type === "set-default") {
-    if (!stored) {
-      stored = resolveMode().mode;
-      try { writeSessionMode("opencode", key, stored); }
-      catch (error) { return `Failed to initialize Necktie session mode: ${error.message}`; }
-    }
-    try {
-      const written = writeDefaultMode(parsed.mode);
-      return written.environmentOverride
-        ? `Saved default ${written.writtenMode}, but NECKTIE_DEFAULT_MODE keeps the effective default at ${written.mode}. Current session remains ${stored}.`
-        : `Default Necktie mode set to ${written.writtenMode} for new sessions. Current session remains ${stored}.`;
-    } catch (error) {
-      return `Failed to save Necktie default: ${error.message}. Current session remains ${stored}.`;
-    }
-  }
-  return formatStatus(resolveMode({ sessionMode: stored }));
+  return executeModeCommand(parseModeArguments(input.arguments), {
+    sessionMode: readSessionMode("opencode", key),
+    saveSession: (mode) => writeSessionMode("opencode", key, mode),
+  }).message;
 }
 
 export default async function necktiePlugin({ client } = {}) {
@@ -84,12 +58,9 @@ export default async function necktiePlugin({ client } = {}) {
     "experimental.chat.system.transform": async (input, output) => {
       const resolution = activeMode(input);
       for (const warning of resolution.warnings) log(warning);
-      const message = commandMessages.get(sessionKey(input));
-      commandMessages.delete(sessionKey(input));
-      const instructions = buildInstructions(resolution.mode, { root });
-      const context = message
-        ? `${message}\n\nAcknowledge this mode result concisely. Do not treat it as a decision request.\n\n${instructions}`
-        : instructions;
+      const key = sessionKey(input);
+      const context = buildContext(resolution.mode, commandMessages.get(key), { root });
+      commandMessages.delete(key);
       if (output.system.length) output.system[output.system.length - 1] += `\n\n${context}`;
       else output.system.push(context);
     },

package/.qoder-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "necktie",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "An opinionated agent policy for decisions shaped by incentives, metrics, power, and hidden costs.",
   "author": { "name": "gillcash", "url": "https://github.com/gillcash" },
   "homepage": "https://github.com/gillcash/necktie",

package/NOTICE

@@ -1,4 +1,4 @@
-Necktie 0.5.2
+Necktie 0.6.0
 Copyright (c) 2026 gillcash
 
 Portions of Ponytail's cross-host packaging, adapter patterns, and test architecture are used under the MIT License.

package/README.md

@@ -60,7 +60,7 @@ Necktie leads with a verdict or completed outcome, names the incentive or power
 
 The root `plugin.json` targets the [Agent Plugins 1.0.0 specification](https://agent-plugins.org/). The portable surface contains the `necktie` judgment skill and the `necktie-research` prompt-building skill.
 
-`skills/necktie/references/policy.md` is the canonical policy source. The build generates self-contained mode references plus one shared `core/` preamble and mode deltas. Static rules inject Full. Dynamic hooks compose the selected mode.
+`skills/necktie/references/policy.md` is the canonical policy source. The build generates self-contained mode references shared by skills and runtime adapters. Static rules inject Full; dynamic hooks load the selected reference.
 
 `necktie-mcp/` is an optional private stdio adapter. Its `necktie` prompt and read-only `necktie_instructions` tool accept a mode per request. MCP does not activate Necktie on every turn and exposes no arbitrary repository, file, execution, network, or mutation operation. The process is not a sandbox: it reads Necktie's bundled policy and optional local default configuration.
 
@@ -167,6 +167,8 @@ python C:/Users/you/.codex/skills/.system/plugin-creator/scripts/validate_plugin
 
 `skills/necktie/references/policy.md` is the source for generated instruction artifacts and static adapters. Do not edit generated copies directly.
 
+The [source map](docs/host-support.md#source-map) connects each entry point to its shared policy, command, and storage code. `npm test` also builds and checks the dependency-free website.
+
 ## License
 
 Necktie is available under the [MIT License](LICENSE). Third-party attribution is recorded in [NOTICE](NOTICE).

package/docs/host-support.md

@@ -51,3 +51,26 @@ The explicit decision skill also accepts `$necktie --mode lite|full <decision>`
 A plugin cannot create a lifecycle event or state primitive that the host does not expose. Static rules provide Full only while the host reads the rule. MCP provides retrieval, not automatic activation. Session files used by lifecycle adapters contain only the selected mode, are keyed by a hash of host/session identity, and expire opportunistically using file age.
 
 Necktie must return one user-facing conclusion on every host. Modes never broaden permissions, authority, or acceptable risk.
+
+## Source map
+
+| Responsibility | Source and callers |
+| --- | --- |
+| Policy text | `skills/necktie/references/policy.md` → `scripts/build-adapters.js` → shared mode references, static host rules, and standalone OpenClaw packages |
+| Mode precedence and configuration | `lib/necktie-policy.cjs`; used by the JavaScript adapters and MCP |
+| Command parsing, execution, and response text | `lib/necktie-command.cjs`; shared by lifecycle hooks, OpenCode, and Pi |
+| Session storage | `lib/necktie-session.cjs` for hooks and OpenCode; Pi uses native session entries |
+| Atomic JSON writes | `lib/necktie-json.cjs`; shared by configuration and session storage |
+| Hermes | `__init__.py` registers host commands and hooks; `necktie_policy.py` resolves modes, stores defaults, and reads the same generated policy text |
+| Research loop | `skills/necktie-research/scripts/research_prompt_loop.py` parses CLI commands; `research_state.py` validates packets, saves them, and enforces bounded transitions |
+| Website | `website/` contains the static page, styles, assets, and dependency-free build and local preview commands |
+
+Edit policy and research sources under `skills/`, then run `npm run build:adapters`.
+The generator builds all expected outputs in memory before writing them, so one
+pass repairs drift without reading stale generated policies. `--check` reports
+missing, changed, and obsolete outputs without changing files. Generated copies
+remain committed because hosts install from Git and OpenClaw skills travel alone.
+
+Run `npm test` for adapter, MCP, Python, generator, and website checks.
+JavaScript and Python retain native configuration implementations so installing
+the Hermes adapter does not require Node merely to resolve a mode.

package/hooks/necktie-context.js

@@ -3,8 +3,8 @@
 
 const path = require("node:path");
 
-const { buildInstructions, resolveMode, writeDefaultMode } = require("../lib/necktie-policy.cjs");
-const { USAGE, formatStatus, parseModeCommand } = require("../lib/necktie-command.cjs");
+const { resolveMode } = require("../lib/necktie-policy.cjs");
+const { buildContext, executeModeCommand, parseModeCommand } = require("../lib/necktie-command.cjs");
 const { readSessionMode, sessionIdentifier, writeSessionMode } = require("../lib/necktie-session.cjs");
 
 function pluginRoot(env = process.env) {
@@ -20,66 +20,36 @@ function host(env = process.env) {
 }
 
 function promptText(input = {}) {
-  for (const value of [input.prompt, input.text, input.userPrompt, input.user_prompt]) {
-    if (typeof value === "string") return value.trim();
-  }
-  return "";
+  return [input.prompt, input.text, input.userPrompt, input.user_prompt]
+    .find((value) => typeof value === "string")?.trim() || "";
 }
 
 function evaluate(event, env = process.env, explicitHost = "", input = {}, options = {}) {
   const detectedHost = explicitHost || host(env);
   const identifier = sessionIdentifier(input, env, options.sessionOptions);
   let sessionMode = readSessionMode(detectedHost, identifier, options.sessionOptions);
-  const initial = resolveMode({ sessionMode, env, configOptions: options.configOptions });
+  const saveSession = (mode) => writeSessionMode(detectedHost, identifier, mode, options.sessionOptions);
   let stateWarning = "";
 
   // Persist the initial default in session scope before handling a default write,
   // so `/necktie-mode default ...` never changes the current session implicitly.
   if (!sessionMode) {
+    sessionMode = resolveMode({ env, configOptions: options.configOptions }).mode;
     try {
-      sessionMode = writeSessionMode(detectedHost, identifier, initial.mode, options.sessionOptions);
+      saveSession(sessionMode);
     } catch (error) {
-      sessionMode = initial.mode;
       stateWarning = `Could not persist Necktie session mode: ${error.message}`;
     }
   }
 
   const parsed = event === "UserPromptSubmit" ? parseModeCommand(promptText(input)) : null;
-  let message = "";
-
-  if (parsed?.type === "set-session") {
-    try {
-      sessionMode = writeSessionMode(detectedHost, identifier, parsed.mode, options.sessionOptions);
-      message = `Necktie mode set to ${sessionMode} for this session.`;
-    } catch (error) {
-      message = `Failed to save Necktie session mode: ${error.message}`;
-    }
-  } else if (parsed?.type === "set-default") {
-    const before = resolveMode({ sessionMode, env, configOptions: options.configOptions });
-    try {
-      const written = writeDefaultMode(parsed.mode, env, options.configOptions);
-      message = written.environmentOverride
-        ? `Saved default ${written.writtenMode}, but NECKTIE_DEFAULT_MODE keeps the effective default at ${written.mode}. Current session remains ${before.mode}.`
-        : `Default Necktie mode set to ${written.writtenMode} for new sessions. Current session remains ${before.mode}.`;
-    } catch (error) {
-      message = `Failed to save Necktie default: ${error.message}. Current session remains ${before.mode}.`;
-    }
-  } else if (parsed?.type === "invalid") {
-    message = parsed.usage || USAGE;
-  }
-
-  const resolution = resolveMode({ sessionMode, env, configOptions: options.configOptions });
+  const { resolution, message } = executeModeCommand(parsed, {
+    sessionMode: stateWarning ? null : sessionMode, saveSession, env, configOptions: options.configOptions,
+  });
   if (stateWarning) resolution.warnings.push(stateWarning);
-  if (parsed?.type === "status") message = formatStatus(resolution);
-
-  const instructions = buildInstructions(resolution.mode, { root: pluginRoot(env) });
-  const context = message
-    ? `${message}\n\nAcknowledge this mode result concisely. Do not treat it as a decision request.\n\n${instructions}`
-    : instructions;
-
   return {
     command: parsed,
-    context,
+    context: buildContext(resolution.mode, message, { root: pluginRoot(env) }),
     host: detectedHost,
     message,
     resolution,
@@ -95,11 +65,6 @@ function hostPayload(event, context, detectedHost) {
   return context;
 }
 
-function payload(event, env = process.env, explicitHost = "", input = {}, options = {}) {
-  const result = evaluate(event, env, explicitHost, input, options);
-  return hostPayload(event, result.context, result.host);
-}
-
 function readHookInput(stream = process.stdin, timeoutMs = 1000) {
   if (!stream || stream.isTTY) return Promise.resolve({});
   return new Promise((resolve) => {
@@ -148,7 +113,6 @@ module.exports = {
   host,
   hostPayload,
   main,
-  payload,
   pluginRoot,
   promptText,
   readHookInput,

package/lib/necktie-command.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-const { normalizeMode } = require("./necktie-policy.cjs");
+const { buildInstructions, normalizeMode, resolveMode, writeDefaultMode } = require("./necktie-policy.cjs");
 
 const USAGE = "Usage: /necktie-mode [status|lite|full|default <lite|full>]";
 
@@ -9,22 +9,17 @@ function extractArguments(text) {
   const marker = value.match(/^\[NECKTIE_MODE_COMMAND\][ \t]*([^\r\n]*)/i);
   if (marker) return marker[1].trim();
   const command = value.match(/^[/@$](?:[^\s:]+:)?necktie-mode(?:\s+([\s\S]*))?$/i);
-  if (command) return String(command[1] || "").trim();
-  return null;
+  return command ? (command[1] || "").trim() : null;
 }
 
 function parseModeArguments(rawArguments) {
   const raw = String(rawArguments || "").trim();
   if (!raw || raw.toLowerCase() === "status") return { type: "status" };
   const parts = raw.split(/\s+/);
-  if (parts[0].toLowerCase() === "default") {
-    if (parts.length !== 2) return { type: "invalid", usage: USAGE };
-    const mode = normalizeMode(parts[1]);
-    return mode ? { type: "set-default", mode } : { type: "invalid", usage: USAGE };
-  }
-  if (parts.length !== 1) return { type: "invalid", usage: USAGE };
-  const mode = normalizeMode(parts[0]);
-  return mode ? { type: "set-session", mode } : { type: "invalid", usage: USAGE };
+  const isDefault = parts[0].toLowerCase() === "default";
+  const mode = normalizeMode(parts.at(-1));
+  if (!mode || parts.length !== (isDefault ? 2 : 1)) return { type: "invalid", usage: USAGE };
+  return { type: isDefault ? "set-default" : "set-session", mode };
 }
 
 function parseModeCommand(text) {
@@ -40,4 +35,53 @@ function formatStatus(resolution) {
   return `Necktie mode: current ${resolution.mode}; configured default ${configuredDefault}.${override}`;
 }
 
-module.exports = { USAGE, extractArguments, formatStatus, parseModeArguments, parseModeCommand };
+function executeModeCommand(command, { sessionMode, saveSession, env = process.env, configOptions } = {}) {
+  let resolution = resolveMode({ sessionMode, env, configOptions });
+  let message = "";
+  switch (command?.type) {
+    case "invalid":
+      message = command.usage || USAGE;
+      break;
+    case "status":
+      message = formatStatus(resolution);
+      break;
+    case "set-session":
+      try {
+        saveSession(command.mode);
+        resolution = resolveMode({ sessionMode: command.mode, env, configOptions });
+        message = `Necktie mode set to ${command.mode} for this session.`;
+      } catch (error) {
+        message = `Failed to save Necktie session mode: ${error.message}`;
+      }
+      break;
+    case "set-default":
+      // Pin the current default before changing what future sessions inherit.
+      try { saveSession(resolution.mode); }
+      catch (error) {
+        return { resolution, message: `Failed to initialize Necktie session mode: ${error.message}` };
+      }
+      try {
+        const written = writeDefaultMode(command.mode, env, configOptions);
+        resolution = resolveMode({ sessionMode: resolution.mode, env, configOptions });
+        message = written.environmentOverride
+          ? `Saved default ${written.writtenMode}, but NECKTIE_DEFAULT_MODE keeps the effective default at ${written.mode}.`
+          : `Default Necktie mode set to ${written.writtenMode} for new sessions.`;
+      } catch (error) {
+        message = `Failed to save Necktie default: ${error.message}.`;
+      }
+      message += ` Current session remains ${resolution.mode}.`;
+      break;
+  }
+  return { resolution, message };
+}
+
+function buildContext(mode, message = "", options = {}) {
+  const instructions = buildInstructions(mode, options);
+  return message
+    ? `${message}\n\nAcknowledge this mode result concisely. Do not treat it as a decision request.\n\n${instructions}`
+    : instructions;
+}
+
+module.exports = {
+  USAGE, buildContext, executeModeCommand, extractArguments, formatStatus, parseModeArguments, parseModeCommand,
+};

package/lib/necktie-json.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+const { randomUUID } = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function writeJson(target, value) {
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const temporary = `${target}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
+      encoding: "utf8", mode: 0o600, flag: "wx",
+    });
+    fs.renameSync(temporary, target);
+  } finally {
+    try { fs.rmSync(temporary, { force: true }); } catch (_) {}
+  }
+}
+
+module.exports = { writeJson };

package/lib/necktie-policy.cjs

@@ -3,6 +3,7 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
+const { writeJson } = require("./necktie-json.cjs");
 
 const MODES = Object.freeze(["lite", "full", "mammon"]);
 const DEFAULT_MODE = "full";
@@ -49,28 +50,20 @@ function readConfig(env = process.env, options = {}) {
 }
 
 function resolveDefaultMode(env = process.env, options = {}) {
+  const loaded = readConfig(env, options);
   const warnings = [];
-  let environmentMode = null;
   const environmentValue = env.NECKTIE_DEFAULT_MODE;
-  if (environmentValue !== undefined) {
-    environmentMode = normalizeMode(environmentValue);
-    if (!environmentMode) warnings.push(`Ignored invalid NECKTIE_DEFAULT_MODE value: ${String(environmentValue)}.`);
+  const environmentMode = normalizeMode(environmentValue);
+  const configured = normalizeMode(loaded.config.defaultMode);
+  if (environmentValue !== undefined && !environmentMode) {
+    warnings.push(`Ignored invalid NECKTIE_DEFAULT_MODE value: ${String(environmentValue)}.`);
   }
-
-  const loaded = readConfig(env, options);
   if (loaded.warning) warnings.push(loaded.warning);
-  let configuredMode = DEFAULT_MODE;
-  let configuredSource = "built-in";
-  if (loaded.config.defaultMode !== undefined) {
-    const configured = normalizeMode(loaded.config.defaultMode);
-    if (configured) {
-      configuredMode = configured;
-      configuredSource = "config";
-    } else {
-      warnings.push(`Ignored invalid defaultMode in ${loaded.path}.`);
-    }
+  if (loaded.config.defaultMode !== undefined && !configured) {
+    warnings.push(`Ignored invalid defaultMode in ${loaded.path}.`);
   }
-
+  const configuredMode = configured || DEFAULT_MODE;
+  const configuredSource = configured ? "config" : "built-in";
   return {
     mode: environmentMode || configuredMode,
     source: environmentMode ? "environment" : configuredSource,
@@ -85,44 +78,23 @@ function resolveDefaultMode(env = process.env, options = {}) {
 function resolveMode({ requestedMode, sessionMode, env = process.env, configOptions = {} } = {}) {
   const defaultResolution = resolveDefaultMode(env, configOptions);
   const warnings = [...defaultResolution.warnings];
-
+  let { mode, source } = defaultResolution;
   if (requestedMode !== undefined && requestedMode !== null) {
-    const requested = normalizeMode(requestedMode);
-    if (!requested) throw new InvalidModeError(requestedMode);
-    return {
-      mode: requested,
-      source: "requested",
-      defaultMode: defaultResolution.mode,
-      defaultSource: defaultResolution.source,
-      configuredDefaultMode: defaultResolution.configuredMode,
-      configuredDefaultSource: defaultResolution.configuredSource,
-      environmentOverride: defaultResolution.environmentOverride,
-      configPath: defaultResolution.configPath,
-      warnings,
-    };
-  }
-
-  if (sessionMode !== undefined && sessionMode !== null && sessionMode !== "") {
+    mode = normalizeMode(requestedMode);
+    if (!mode) throw new InvalidModeError(requestedMode);
+    source = "requested";
+  } else if (sessionMode !== undefined && sessionMode !== null && sessionMode !== "") {
     const session = normalizeMode(sessionMode);
     if (session) {
-      return {
-        mode: session,
-        source: "session",
-        defaultMode: defaultResolution.mode,
-        defaultSource: defaultResolution.source,
-        configuredDefaultMode: defaultResolution.configuredMode,
-        configuredDefaultSource: defaultResolution.configuredSource,
-        environmentOverride: defaultResolution.environmentOverride,
-        configPath: defaultResolution.configPath,
-        warnings,
-      };
+      mode = session;
+      source = "session";
+    } else {
+      warnings.push(`Ignored invalid stored Necktie session mode: ${String(sessionMode)}.`);
     }
-    warnings.push(`Ignored invalid stored Necktie session mode: ${String(sessionMode)}.`);
   }
-
   return {
-    mode: defaultResolution.mode,
-    source: defaultResolution.source,
+    mode,
+    source,
     defaultMode: defaultResolution.mode,
     defaultSource: defaultResolution.source,
     configuredDefaultMode: defaultResolution.configuredMode,
@@ -137,25 +109,15 @@ function buildInstructions(mode = DEFAULT_MODE, options = {}) {
   const normalized = normalizeMode(mode);
   if (!normalized) throw new InvalidModeError(mode);
   const root = options.root ? path.resolve(options.root) : ROOT;
-  const read = (name) => fs.readFileSync(path.join(root, "core", name), "utf8")
+  return fs.readFileSync(path.join(root, "skills/necktie/references", `${normalized}.md`), "utf8")
     .replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").trim();
-  return `${read("necktie-core.md").replace("<MODE>", normalized)}\n\n${read(`necktie-${normalized}.md`)}`;
 }
 
 function writeDefaultMode(mode, env = process.env, options = {}) {
   const normalized = normalizeMode(mode);
   if (!normalized) throw new InvalidModeError(mode);
   const loaded = readConfig(env, options);
-  const config = { ...loaded.config, defaultMode: normalized };
-  const target = loaded.path;
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
-  try {
-    fs.writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-    fs.renameSync(temporary, target);
-  } finally {
-    try { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); } catch (_) {}
-  }
+  writeJson(loaded.path, { ...loaded.config, defaultMode: normalized });
   return {
     writtenMode: normalized,
     ...resolveDefaultMode(env, options),

package/lib/necktie-session.cjs

@@ -6,6 +6,7 @@ const os = require("node:os");
 const path = require("node:path");
 
 const { normalizeMode } = require("./necktie-policy.cjs");
+const { writeJson } = require("./necktie-json.cjs");
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 function stateDirectory(options = {}) {
@@ -61,18 +62,7 @@ function readSessionMode(host, sessionId, options = {}) {
 function writeSessionMode(host, sessionId, mode, options = {}) {
   const normalized = normalizeMode(mode);
   if (!normalized) return null;
-  const target = statePath(host, sessionId, options);
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    fs.writeFileSync(temporary, `${JSON.stringify({ mode: normalized })}\n`, {
-      encoding: "utf8",
-      mode: 0o600,
-    });
-    fs.renameSync(temporary, target);
-  } finally {
-    try { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); } catch (_) {}
-  }
+  writeJson(statePath(host, sessionId, options), { mode: normalized });
   return normalized;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gillcash/necktie",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "An opinionated agent policy for decisions shaped by incentives, metrics, power, and hidden costs.",
   "keywords": ["agent-plugin", "incentives", "power", "externalities", "opinionated-agent", "research-prompts"],
   "license": "MIT",
@@ -24,7 +24,6 @@
   "files": [
     "AGENTS.md",
     "plugin.json",
-    "core/",
     "lib/",
     "hooks/",
     "skills/",
@@ -43,12 +42,12 @@
     "!pi-extension/test/**"
   ],
   "scripts": {
-    "build:policy": "node scripts/build-policy.js",
-    "build:adapters": "npm run build:policy && node scripts/build-adapters.js && node scripts/build-openclaw-skills.js",
-    "check:policy": "node scripts/build-policy.js --check",
-    "check:adapters": "npm run check:policy && node scripts/build-adapters.js --check && node scripts/build-openclaw-skills.js --check",
+    "build:policy": "node scripts/build-adapters.js",
+    "build:adapters": "node scripts/build-adapters.js",
+    "check:policy": "node scripts/build-adapters.js --check",
+    "check:adapters": "node scripts/build-adapters.js --check",
     "check:versions": "node scripts/check-versions.js",
-    "test": "npm run check:adapters && npm run check:versions && node --test tests/*.test.js tests/*.test.mjs && npm test --prefix pi-extension && npm test --prefix necktie-mcp && python -m unittest discover -s tests -p test_*.py"
+    "test": "npm run check:adapters && npm run check:versions && node --test tests/*.test.js tests/*.test.mjs && npm test --prefix pi-extension && npm test --prefix necktie-mcp && python -m unittest discover -s tests -p test_*.py && npm test --prefix website"
   },
   "pi": {
     "extensions": ["./pi-extension/index.js"],

package/pi-extension/index.js

@@ -1,12 +1,7 @@
-import { createRequire } from "node:module";
+import { DEFAULT_MODE, buildInstructions, normalizeMode, resolveMode } from "../lib/necktie-policy.cjs";
+import { executeModeCommand, parseModeArguments } from "../lib/necktie-command.cjs";
 
-const require = createRequire(import.meta.url);
-const { DEFAULT_MODE, buildInstructions, normalizeMode, resolveMode, writeDefaultMode } = require("../lib/necktie-policy.cjs");
-const { USAGE, formatStatus, parseModeArguments } = require("../lib/necktie-command.cjs");
-
-export function coreContext(mode = DEFAULT_MODE) {
-  return buildInstructions(mode);
-}
+export { buildInstructions as coreContext, parseModeArguments as parseNecktieModeCommand };
 
 export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
   const fallback = normalizeMode(fallbackMode) || DEFAULT_MODE;
@@ -20,10 +15,6 @@ export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
   return fallback;
 }
 
-export function parseNecktieModeCommand(text) {
-  return parseModeArguments(text);
-}
-
 export function sendSkill(pi, skill, args, ctx) {
   const suffix = String(args || "").trim();
   const message = suffix ? `/skill:${skill} ${suffix}` : `/skill:${skill}`;
@@ -32,8 +23,7 @@ export function sendSkill(pi, skill, args, ctx) {
 }
 
 export default function necktieExtension(pi) {
-  let configuredDefault = resolveMode();
-  let currentMode = configuredDefault.mode;
+  let currentMode = resolveMode().mode;
 
   pi.registerCommand("necktie", {
     description: "Run /skill:necktie",
@@ -44,37 +34,18 @@ export default function necktieExtension(pi) {
     description: "Set Necktie mode: lite or full. Commands: status, default <mode>",
     handler: async (args, ctx) => {
       const parsed = parseModeArguments(args);
-      let message;
-      if (parsed.type === "set-session") {
-        try {
-          pi.appendEntry?.("necktie-mode", { mode: parsed.mode });
-          currentMode = parsed.mode;
-          message = `Necktie mode set to ${currentMode} for this session.`;
-        } catch (error) {
-          message = `Failed to save Necktie session mode: ${error.message}`;
-        }
-      } else if (parsed.type === "set-default") {
-        try {
-          const written = writeDefaultMode(parsed.mode);
-          configuredDefault = resolveMode();
-          message = written.environmentOverride
-            ? `Saved default ${written.writtenMode}, but NECKTIE_DEFAULT_MODE keeps the effective default at ${written.mode}. Current session remains ${currentMode}.`
-            : `Default Necktie mode set to ${written.writtenMode} for new sessions. Current session remains ${currentMode}.`;
-        } catch (error) {
-          message = `Failed to save Necktie default: ${error.message}`;
-        }
-      } else if (parsed.type === "status") {
-        message = formatStatus(resolveMode({ sessionMode: currentMode }));
-      } else {
-        message = parsed.usage || USAGE;
-      }
+      const { resolution, message } = executeModeCommand(parsed, {
+        sessionMode: currentMode,
+        saveSession: (mode) => pi.appendEntry?.("necktie-mode", { mode }),
+      });
+      currentMode = resolution.mode;
       ctx?.ui?.notify?.(message, parsed.type === "invalid" ? "warning" : "info");
       return message;
     },
   });
 
   pi.on("session_start", async (_event, ctx) => {
-    configuredDefault = resolveMode();
+    const configuredDefault = resolveMode();
     for (const warning of configuredDefault.warnings) ctx?.ui?.notify?.(warning, "warning");
     const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
     currentMode = resolveSessionMode(entries, configuredDefault.mode);
@@ -82,6 +53,6 @@ export default function necktieExtension(pi) {
 
   pi.on("before_agent_start", async (event) => {
     const base = event?.systemPrompt ? `${event.systemPrompt}\n\n` : "";
-    return { systemPrompt: `${base}${coreContext(currentMode)}` };
+    return { systemPrompt: `${base}${buildInstructions(currentMode)}` };
   });
 }

package/pi-extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gillcash/necktie-pi-extension",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "scripts": {

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "necktie",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "An opinionated agent policy for decisions shaped by incentives, metrics, power, and hidden costs.",
   "author": {
     "name": "gillcash",

package/skills/necktie-research/scripts/research_prompt_loop.py

@@ -1,298 +1,58 @@
 #!/usr/bin/env python3
 """Create and advance an auditable Necktie research-prompt run packet."""
 
-from __future__ import annotations
-
 import argparse
-from datetime import datetime, timezone
 import json
 from pathlib import Path
 import sys
-import uuid
-
-
-SCHEMA_VERSION = "1.0"
-REVISION_LIMITS = {"standard": 3, "deep": 5}
-ORIGIN_MODES = {"full", "mammon"}
-STATES = {
-    "intake",
-    "discover",
-    "fingerprint",
-    "critique",
-    "blueprint",
-    "draft",
-    "review",
-    "revise",
-    "verify",
-    "complete",
-    "blocked",
-}
-ALLOWED_TRANSITIONS = {
-    "intake": {"discover"},
-    "discover": {"fingerprint"},
-    "fingerprint": {"critique"},
-    "critique": {"blueprint"},
-    "blueprint": {"draft"},
-    "draft": {"review"},
-    "revise": {"review"},
-}
-
-
-class LoopError(ValueError):
-    """Raised for an invalid run packet or state transition."""
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
-
-
-def event(kind: str, **details: object) -> dict[str, object]:
-    return {"at": utc_now(), "kind": kind, **details}
-
-
-def new_packet(goal: str, depth: str, origin_mode: str) -> dict[str, object]:
-    goal = goal.strip()
-    if not goal:
-        raise LoopError("goal must not be empty")
-    if depth not in REVISION_LIMITS:
-        raise LoopError(f"unsupported depth: {depth}")
-    if origin_mode not in ORIGIN_MODES:
-        raise LoopError(f"unsupported origin mode: {origin_mode}")
-    now = utc_now()
-    return {
-        "schema_version": SCHEMA_VERSION,
-        "run_id": str(uuid.uuid4()),
-        "created_at": now,
-        "updated_at": now,
-        "goal": goal,
-        "depth": depth,
-        "origin_mode": origin_mode,
-        "state": "intake",
-        "audience": "",
-        "target_deliverables": [],
-        "acceptance_criteria": [],
-        "constraints": [],
-        "non_goals": [],
-        "sources": [],
-        "reference_fingerprint": {},
-        "assumptions": [],
-        "strongest_unasked_question": "",
-        "prompt_path": "",
-        "review_history": [],
-        "verification_history": [],
-        "circuit_breaker": None,
-        "history": [event("initialized", state="intake")],
-    }
-
-
-def validate_packet(packet: object) -> dict[str, object]:
-    if not isinstance(packet, dict):
-        raise LoopError("run packet must be a JSON object")
-    required = {
-        "schema_version",
-        "run_id",
-        "goal",
-        "depth",
-        "origin_mode",
-        "state",
-        "review_history",
-        "verification_history",
-        "history",
-    }
-    missing = sorted(required - packet.keys())
-    if missing:
-        raise LoopError(f"run packet is missing: {', '.join(missing)}")
-    if packet["schema_version"] != SCHEMA_VERSION:
-        raise LoopError(f"unsupported schema_version: {packet['schema_version']}")
-    if packet["depth"] not in REVISION_LIMITS:
-        raise LoopError(f"unsupported depth: {packet['depth']}")
-    if packet["origin_mode"] not in ORIGIN_MODES:
-        raise LoopError(f"unsupported origin mode: {packet['origin_mode']}")
-    if packet["state"] not in STATES:
-        raise LoopError(f"unsupported state: {packet['state']}")
-    for key in ("review_history", "verification_history", "history"):
-        if not isinstance(packet[key], list):
-            raise LoopError(f"{key} must be an array")
-    return packet
-
-
-def load_packet(path: Path) -> dict[str, object]:
-    try:
-        return validate_packet(json.loads(path.read_text(encoding="utf-8")))
-    except FileNotFoundError as exc:
-        raise LoopError(f"run packet not found: {path}") from exc
-    except json.JSONDecodeError as exc:
-        raise LoopError(f"invalid JSON in {path}: {exc}") from exc
-
 
-def save_packet(path: Path, packet: dict[str, object]) -> None:
-    validate_packet(packet)
-    packet["updated_at"] = utc_now()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_suffix(path.suffix + ".tmp")
-    temporary.write_text(json.dumps(packet, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    temporary.replace(path)
+from research_state import (
+    ORIGIN_MODES, REVISION_LIMITS, STATES, LoopError, load_packet, new_packet,
+    record_review, record_verification, save_packet, transition,
+)
 
-
-def transition(packet: dict[str, object], target: str, note: str) -> None:
-    current = str(packet["state"])
-    if target not in ALLOWED_TRANSITIONS.get(current, set()):
-        allowed = ", ".join(sorted(ALLOWED_TRANSITIONS.get(current, set()))) or "none"
-        raise LoopError(f"cannot transition from {current} to {target}; allowed: {allowed}")
-    packet["state"] = target
-    packet["history"].append(event("transition", previous=current, state=target, note=note.strip()))
-
-
-def revision_count(packet: dict[str, object]) -> int:
-    return sum(review["decision"] == "REVISE" for review in packet["review_history"])
-
-
-def record_review(
-    packet: dict[str, object], decision: str, reason: str, issue_signature: str
-) -> None:
-    if packet["state"] != "review":
-        raise LoopError(f"review decisions require state=review, found {packet['state']}")
-    decision = decision.upper()
-    if decision not in {"APPROVE", "REVISE", "BLOCK"}:
-        raise LoopError(f"unsupported review decision: {decision}")
-    reason = reason.strip()
-    if not reason:
-        raise LoopError("review reason must not be empty")
-    signature = issue_signature.strip()
-    if decision == "REVISE" and not signature:
-        raise LoopError("REVISE requires --issue-signature")
-
-    reviews = packet["review_history"]
-    reviews.append(
-        event(
-            "review",
-            attempt=len(reviews) + 1,
-            decision=decision,
-            reason=reason,
-            issue_signature=signature,
-        )
-    )
-
-    if decision == "APPROVE":
-        packet["state"] = "verify"
-    elif decision == "BLOCK":
-        packet["state"] = "blocked"
-        packet["circuit_breaker"] = "reviewer-blocked"
-    else:
-        same_issue_count = 0
-        for review in reversed(reviews):
-            if review["decision"] == "REVISE" and review["issue_signature"] == signature:
-                same_issue_count += 1
-            else:
-                break
-        if same_issue_count >= 3:
-            packet["state"] = "blocked"
-            packet["circuit_breaker"] = "same-issue-three-times"
-        elif revision_count(packet) > REVISION_LIMITS[str(packet["depth"])]:
-            packet["state"] = "blocked"
-            packet["circuit_breaker"] = "revision-limit-exceeded"
-        else:
-            packet["state"] = "revise"
-
-    packet["history"].append(
-        event("review-decision", decision=decision, state=packet["state"], reason=reason)
-    )
-
-
-def record_verification(
-    packet: dict[str, object], result: str, reason: str, issue_signature: str
-) -> None:
-    if packet["state"] != "verify":
-        raise LoopError(f"verification requires state=verify, found {packet['state']}")
-    result = result.upper()
-    if result not in {"PASS", "FAIL"}:
-        raise LoopError(f"unsupported verification result: {result}")
-    reason = reason.strip()
-    if not reason:
-        raise LoopError("verification reason must not be empty")
-    signature = issue_signature.strip()
-    if result == "FAIL" and not signature:
-        raise LoopError("FAIL requires --issue-signature")
-
-    verifications = packet["verification_history"]
-    verifications.append(
-        event(
-            "verification",
-            attempt=len(verifications) + 1,
-            result=result,
-            reason=reason,
-            issue_signature=signature,
-        )
-    )
-    if result == "PASS":
-        packet["state"] = "complete"
-    elif revision_count(packet) >= REVISION_LIMITS[str(packet["depth"])]:
-        packet["state"] = "blocked"
-        packet["circuit_breaker"] = "verification-failed-after-revision-limit"
-    else:
-        packet["state"] = "revise"
-    packet["history"].append(
-        event("verification-result", result=result, state=packet["state"], reason=reason)
-    )
+ACTIONS = {"transition": transition, "review": record_review, "verify": record_verification}
 
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    initialize = subparsers.add_parser("init", help="create a new research-prompt run packet")
+    commands = parser.add_subparsers(dest="command", required=True)
+    initialize = commands.add_parser("init", help="create a research-prompt run packet")
     initialize.add_argument("--goal", required=True)
     initialize.add_argument("--depth", choices=sorted(REVISION_LIMITS), default="standard")
     initialize.add_argument("--origin-mode", choices=sorted(ORIGIN_MODES), default="full")
-    initialize.add_argument("--output", type=Path, required=True)
-
-    advance = subparsers.add_parser("transition", help="advance to an allowed phase")
-    advance.add_argument("--file", type=Path, required=True)
-    advance.add_argument("--to", choices=sorted(STATES), required=True)
-    advance.add_argument("--note", default="")
-
-    review = subparsers.add_parser("review", help="record a frozen-draft review decision")
-    review.add_argument("--file", type=Path, required=True)
-    review.add_argument("--decision", choices=["APPROVE", "REVISE", "BLOCK"], required=True)
-    review.add_argument("--reason", required=True)
-    review.add_argument("--issue-signature", default="")
-
-    verify = subparsers.add_parser("verify", help="record fresh-session verification")
-    verify.add_argument("--file", type=Path, required=True)
-    verify.add_argument("--result", choices=["PASS", "FAIL"], required=True)
-    verify.add_argument("--reason", required=True)
-    verify.add_argument("--issue-signature", default="")
-
-    show = subparsers.add_parser("show", help="validate and print a run packet")
-    show.add_argument("--file", type=Path, required=True)
+    initialize.add_argument("--output", dest="file", type=Path, required=True)
+    parsers = {name: commands.add_parser(name, help=help_text) for name, help_text in {
+        "transition": "advance to an allowed phase",
+        "review": "record a frozen-draft review decision",
+        "verify": "record fresh-session verification",
+        "show": "validate and print a run packet",
+    }.items()}
+    for command in parsers.values():
+        command.add_argument("--file", type=Path, required=True)
+    parsers["transition"].add_argument("--to", dest="target", choices=sorted(STATES), required=True)
+    parsers["transition"].add_argument("--note", default="")
+    for name, field, choices in (("review", "decision", ("APPROVE", "REVISE", "BLOCK")),
+                                 ("verify", "result", ("PASS", "FAIL"))):
+        parsers[name].add_argument(f"--{field}", choices=choices, required=True)
+        parsers[name].add_argument("--reason", required=True)
+        parsers[name].add_argument("--issue-signature", default="")
     return parser
 
 
-def main(argv: list[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
+def main(argv=None) -> int:
+    options = vars(build_parser().parse_args(argv))
+    command, path = options.pop("command"), options.pop("file")
     try:
-        if args.command == "init":
-            packet = new_packet(args.goal, args.depth, args.origin_mode)
-            save_packet(args.output, packet)
-            print(f"initialized {packet['run_id']} at {args.output}")
-        elif args.command == "transition":
-            packet = load_packet(args.file)
-            transition(packet, args.to, args.note)
-            save_packet(args.file, packet)
-            print(f"state={packet['state']}")
-        elif args.command == "review":
-            packet = load_packet(args.file)
-            record_review(packet, args.decision, args.reason, args.issue_signature)
-            save_packet(args.file, packet)
-            print(f"state={packet['state']}")
-        elif args.command == "verify":
-            packet = load_packet(args.file)
-            record_verification(packet, args.result, args.reason, args.issue_signature)
-            save_packet(args.file, packet)
-            print(f"state={packet['state']}")
-        else:
-            print(json.dumps(load_packet(args.file), indent=2, ensure_ascii=False))
-    except LoopError as exc:
+        packet = new_packet(**options) if command == "init" else load_packet(path)
+        if command == "show":
+            print(json.dumps(packet, indent=2, ensure_ascii=False))
+            return 0
+        if command in ACTIONS:
+            ACTIONS[command](packet, **options)
+        save_packet(path, packet)
+        print(f"initialized {packet['run_id']} at {path}" if command == "init" else f"state={packet['state']}")
+    except (LoopError, OSError) as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 2
     return 0

package/skills/necktie-research/scripts/research_state.py

@@ -0,0 +1,152 @@
+"""Research packet persistence and bounded review/verification transitions."""
+
+from contextlib import suppress
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+from tempfile import mkstemp
+import uuid
+
+SCHEMA_VERSION = "1.0"
+REVISION_LIMITS = {"standard": 3, "deep": 5}
+ORIGIN_MODES = {"full", "mammon"}
+PHASES = "intake discover fingerprint critique blueprint draft review".split()
+ALLOWED_TRANSITIONS = {current: {target} for current, target in zip(PHASES, PHASES[1:])}
+ALLOWED_TRANSITIONS["revise"] = {"review"}
+STATES = set(PHASES) | {"revise", "verify", "complete", "blocked"}
+OUTCOMES = {
+    "review": {"APPROVE": "verify", "REVISE": "revise", "BLOCK": "blocked"},
+    "verification": {"PASS": "complete", "FAIL": "revise"},
+}
+
+
+class LoopError(ValueError):
+    """Invalid run packet or state transition."""
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def event(kind: str, **details) -> dict:
+    return {"at": utc_now(), "kind": kind, **details}
+
+
+def new_packet(goal: str, depth: str, origin_mode: str) -> dict:
+    now = utc_now()
+    return validate_packet({
+        "schema_version": SCHEMA_VERSION, "run_id": str(uuid.uuid4()),
+        "created_at": now, "updated_at": now, "goal": goal.strip() if isinstance(goal, str) else goal,
+        "depth": depth, "origin_mode": origin_mode, "state": "intake",
+        **dict.fromkeys(("audience", "strongest_unasked_question", "prompt_path"), ""),
+        **{key: [] for key in (
+            "target_deliverables", "acceptance_criteria", "constraints", "non_goals",
+            "sources", "assumptions", "review_history", "verification_history",
+        )},
+        "reference_fingerprint": {}, "circuit_breaker": None,
+        "history": [event("initialized", state="intake")],
+    })
+
+
+def validate_packet(packet: object) -> dict:
+    if not isinstance(packet, dict):
+        raise LoopError("run packet must be a JSON object")
+    choices = {"schema_version": {SCHEMA_VERSION}, "depth": REVISION_LIMITS,
+               "origin_mode": ORIGIN_MODES, "state": STATES}
+    for key in (*choices, "run_id", "goal"):
+        value = packet.get(key)
+        if not isinstance(value, str) or not value.strip():
+            raise LoopError(f"{key} must be a nonempty string")
+        if key in choices and value not in choices[key]:
+            raise LoopError(f"unsupported {key}: {value}")
+    for kind in ("review", "verification", ""):
+        key = f"{kind}_history" if kind else "history"
+        records = packet.get(key)
+        if not isinstance(records, list) or any(not isinstance(record, dict) for record in records):
+            raise LoopError(f"{key} must be an array of objects")
+        if kind:
+            field = "decision" if kind == "review" else "result"
+            for record in records:
+                value = record.get(field)
+                if not isinstance(value, str) or value not in OUTCOMES[kind]:
+                    raise LoopError(f"invalid {field} in {key}")
+                signature = record.get("issue_signature")
+                if not isinstance(signature, str) or (value in {"REVISE", "FAIL"} and not signature.strip()):
+                    raise LoopError(f"invalid issue_signature in {key}")
+    return packet
+
+
+def load_packet(path: Path) -> dict:
+    try:
+        return validate_packet(json.loads(path.read_text(encoding="utf-8-sig")))
+    except (OSError, ValueError) as exc:
+        raise LoopError(f"cannot load run packet {path}: {exc}") from exc
+
+
+def save_packet(path: Path, packet: dict) -> None:
+    validate_packet(packet)
+    packet["updated_at"] = utc_now()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, name = mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp")
+    pending = Path(name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as temporary:
+            json.dump(packet, temporary, indent=2, ensure_ascii=False)
+            temporary.write("\n")
+        pending.replace(path)
+    finally:
+        with suppress(OSError):
+            pending.unlink(missing_ok=True)
+
+
+def transition(packet: dict, target: str, note: str) -> None:
+    current = packet["state"]
+    allowed = ALLOWED_TRANSITIONS.get(current, set())
+    if target not in allowed:
+        raise LoopError(f"cannot transition from {current} to {target}; allowed: {', '.join(sorted(allowed)) or 'none'}")
+    packet["state"] = target
+    packet["history"].append(event("transition", previous=current, state=target, note=note.strip()))
+
+
+def revision_count(packet: dict) -> int:
+    return (sum(review["decision"] == "REVISE" for review in packet["review_history"])
+            + sum(check["result"] == "FAIL" for check in packet["verification_history"]))
+
+
+def _record(packet: dict, kind: str, value: str, reason: str, signature: str) -> None:
+    phase, field = ("review", "decision") if kind == "review" else ("verify", "result")
+    if packet["state"] != phase:
+        raise LoopError(f"{kind} requires state={phase}, found {packet['state']}")
+    value, reason, signature = value.upper(), reason.strip(), signature.strip()
+    if value not in OUTCOMES[kind]:
+        raise LoopError(f"unsupported {kind} {field}: {value}")
+    if not reason:
+        raise LoopError(f"{kind} reason must not be empty")
+    if value in {"REVISE", "FAIL"} and not signature:
+        raise LoopError(f"{value} requires --issue-signature")
+    records = packet[f"{kind}_history"]
+    records.append(event(kind, attempt=len(records) + 1, **{field: value}, reason=reason, issue_signature=signature))
+    breaker = None
+    revisions, limit = revision_count(packet), REVISION_LIMITS[packet["depth"]]
+    if value == "BLOCK":
+        breaker = "reviewer-blocked"
+    elif value == "REVISE":
+        if len(records) >= 3 and all(r["decision"] == "REVISE" and r["issue_signature"] == signature for r in records[-3:]):
+            breaker = "same-issue-three-times"
+        elif revisions > limit:
+            breaker = "revision-limit-exceeded"
+    elif value == "FAIL" and revisions > limit:
+        breaker = "verification-failed-after-revision-limit"
+    packet["state"] = "blocked" if breaker else OUTCOMES[kind][value]
+    if breaker:
+        packet["circuit_breaker"] = breaker
+    packet["history"].append(event(f"{kind}-{field}", **{field: value}, state=packet["state"], reason=reason))
+
+
+def record_review(packet: dict, decision: str, reason: str, issue_signature: str) -> None:
+    _record(packet, "review", decision, reason, issue_signature)
+
+
+def record_verification(packet: dict, result: str, reason: str, issue_signature: str) -> None:
+    _record(packet, "verification", result, reason, issue_signature)

package/core/necktie-core.md

@@ -1,17 +0,0 @@
-NECKTIE MODE ACTIVE — level: <MODE>.
-
-# Necktie Core
-
-Necktie is active for every response. Analysis only goes where the decision
-is material: who benefits, who pays, who decides, who can leave; value
-created vs. captured; costs hidden from the metric; behavior the incentive
-rewards; durable vs. fragile. Prefer human agency over metric worship, shared
-value over extraction, truth over convenient narrative, accountable power
-over opaque control. Take a side; don't manufacture disagreement.
-
-Proportionate, not preachy: no forced political commentary, no ideology over
-domain evidence. Never trade away security, privacy, accessibility, input
-validation, or data-loss protection. Never narrate private analysis or a
-debate transcript — surface the conclusion, the material tradeoff, and the
-evidence it needs. Lead with the outcome. Ask only when the answer changes
-the deliverable.

package/core/necktie-full.md

@@ -1,10 +0,0 @@
-Mammon as internal adversary, then rebut — plus two private passes:
-
-- Ambition pass: assume agent capability improves quickly. Is there a
-  higher-leverage authorized build than the smallest intervention?
-- Useful action pass: when work is authorized, do it. When a material
-  response ends at judgment, offer exactly one concrete next artifact
-  (draft, research prompt, implementation).
-
-If that artifact is a research prompt, use `necktie-research`; approval
-authorizes starting immediately.

package/core/necktie-lite.md

@@ -1,5 +0,0 @@
-Mammon is an internal adversary: build the strongest case for accumulation,
-growth, control, rent extraction, lock-in, surveillance, labor/attention
-leverage, and risk-shifting onto the less powerful. Then rebut it using the
-core questions above. Mammon stays internal; never present it as a second
-speaker or quoted dialogue.

package/core/necktie-mammon.md

@@ -1,15 +0,0 @@
-Mammon is the sole final perspective. Give the strongest evidence-based
-recommendation for accumulation, growth, control, market power, rent
-extraction, lock-in, surveillance, labor/attention leverage, and shifting
-cost and risk away from the decision-maker, with the legitimate efficiency,
-speed, scale, and coordination benefits. No rebuttal, no rebalancing toward
-shared value or human agency. Still strategically honest: flag legal,
-security, privacy, operational, labor, reputational, exit, and backlash
-risks; never fabricate evidence, conceal a material downside, exceed the
-user's authority, or bypass safety boundaries.
-
-Useful action pass: do authorized work. When a material response ends at
-judgment, offer exactly one concrete next artifact.
-
-If that artifact is a research prompt, use `necktie-research`; approval
-authorizes starting immediately.