@gillcash/necktie 0.2.0 → 0.4.0

package/hooks/hooks.json

@@ -7,7 +7,7 @@
           {
             "type": "command",
             "command": "node -e \"const r=process.argv[1],e=process.argv[2],g=e&&!e.startsWith('$'+'{')?e:'',p=g||r;require(p+'/hooks/necktie-context.js').main(['SessionStart',g])\" \"${CLAUDE_PLUGIN_ROOT}\" \"${extensionPath}\"",
-            "additionalContextLimit": 1200
+            "additionalContextLimit": 2400
           }
         ]
       }
@@ -18,7 +18,18 @@
           {
             "type": "command",
             "command": "node -e \"const r=process.argv[1],e=process.argv[2],g=e&&!e.startsWith('$'+'{')?e:'',p=g||r;require(p+'/hooks/necktie-context.js').main(['SubagentStart',g])\" \"${CLAUDE_PLUGIN_ROOT}\" \"${extensionPath}\"",
-            "additionalContextLimit": 1200
+            "additionalContextLimit": 2400
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const r=process.argv[1],e=process.argv[2],g=e&&!e.startsWith('$'+'{')?e:'',p=g||r;require(p+'/hooks/necktie-context.js').main(['UserPromptSubmit',g])\" \"${CLAUDE_PLUGIN_ROOT}\" \"${extensionPath}\"",
+            "additionalContextLimit": 2400
           }
         ]
       }

package/hooks/necktie-context.js

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
 "use strict";
 
-const fs = require("node:fs");
 const path = require("node:path");
 
+const { buildInstructions, resolveMode, writeDefaultMode } = require("../lib/necktie-policy.cjs");
+const { USAGE, formatStatus, parseModeCommand } = require("../lib/necktie-command.cjs");
+const { readSessionMode, sessionIdentifier, writeSessionMode } = require("../lib/necktie-session.cjs");
+
 function pluginRoot(env = process.env) {
   return env.PLUGIN_ROOT || env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, "..");
 }
 
-function coreContext(env = process.env) {
-  return fs.readFileSync(path.join(pluginRoot(env), "core", "necktie-core.md"), "utf8").trim();
-}
-
 function host(env = process.env) {
   const compatibilityRoot = env.CLAUDE_PLUGIN_ROOT || "";
   if (env.COPILOT_PLUGIN_DATA || compatibilityRoot.includes(".vscode/agent-plugins")) return "copilot";
@@ -20,24 +19,137 @@ function host(env = process.env) {
   return "claude";
 }
 
-function payload(event, env = process.env, explicitHost = "") {
-  const context = coreContext(env);
-  const detected = explicitHost || host(env);
-  if (detected === "copilot") return { additionalContext: context };
-  if (detected === "codex" || detected === "qoder" || detected === "gemini" || event === "SubagentStart") {
+function promptText(input = {}) {
+  for (const value of [input.prompt, input.text, input.userPrompt, input.user_prompt]) {
+    if (typeof value === "string") return value.trim();
+  }
+  return "";
+}
+
+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 });
+  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) {
+    try {
+      sessionMode = writeSessionMode(detectedHost, identifier, initial.mode, options.sessionOptions);
+    } 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 });
+  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,
+    host: detectedHost,
+    message,
+    resolution,
+    sessionId: identifier,
+  };
+}
+
+function hostPayload(event, context, detectedHost) {
+  if (detectedHost === "copilot") return { additionalContext: context };
+  if (detectedHost === "codex" || detectedHost === "qoder" || detectedHost === "gemini" || event === "SubagentStart") {
     return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
   }
   return context;
 }
 
-function main(argv = process.argv.slice(2), env = process.env) {
+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) => {
+    let raw = "";
+    let finished = false;
+    let timer;
+    const onData = (chunk) => { raw += chunk; };
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      stream.removeListener?.("data", onData);
+      stream.removeListener?.("end", finish);
+      stream.removeListener?.("error", finish);
+      stream.pause?.();
+      try {
+        resolve(raw.trim() ? JSON.parse(raw.replace(/^\uFEFF/, "")) : {});
+      } catch (_) {
+        resolve({});
+      }
+    };
+    stream.setEncoding?.("utf8");
+    stream.on("data", onData);
+    stream.on("end", finish);
+    stream.on("error", finish);
+    timer = setTimeout(finish, timeoutMs);
+  });
+}
+
+async function main(argv = process.argv.slice(2), env = process.env, options = {}) {
   const event = argv[0] || "SessionStart";
   const hint = argv[1] || "";
   const explicitHost = hint === "copilot" || hint === "qoder" ? hint : hint ? "gemini" : "";
-  const result = payload(event, env, explicitHost);
+  const input = options.input || await readHookInput(options.stdin || process.stdin, options.timeoutMs || 1000);
+  const evaluated = evaluate(event, env, explicitHost, input, options);
+  for (const warning of evaluated.resolution.warnings) process.stderr.write(`${warning}\n`);
+  const result = hostPayload(event, evaluated.context, evaluated.host);
   process.stdout.write(typeof result === "string" ? result : JSON.stringify(result));
+  return result;
 }
 
-if (require.main === module) main();
+if (require.main === module) main().catch(() => { process.exitCode = 0; });
 
-module.exports = { coreContext, host, main, payload, pluginRoot };
+module.exports = {
+  evaluate,
+  host,
+  hostPayload,
+  main,
+  payload,
+  pluginRoot,
+  promptText,
+  readHookInput,
+};

package/lib/necktie-command.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+const { MODES, normalizeMode } = require("./necktie-policy.cjs");
+
+const MODE_LIST = MODES.join("|");
+const USAGE = `Usage: /necktie-mode [status|${MODE_LIST}|default <${MODE_LIST}>]`;
+
+function extractArguments(text) {
+  const value = String(text || "").trim();
+  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;
+}
+
+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 };
+}
+
+function parseModeCommand(text) {
+  const args = extractArguments(text);
+  return args === null ? null : parseModeArguments(args);
+}
+
+function formatStatus(resolution) {
+  const override = resolution.environmentOverride
+    ? ` Environment override: ${resolution.environmentOverride}.`
+    : "";
+  const configuredDefault = resolution.configuredDefaultMode || resolution.defaultMode;
+  return `Necktie mode: current ${resolution.mode}; configured default ${configuredDefault}.${override}`;
+}
+
+module.exports = { MODE_LIST, USAGE, extractArguments, formatStatus, parseModeArguments, parseModeCommand };

package/lib/necktie-policy.cjs

@@ -0,0 +1,177 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const MODES = Object.freeze(["lite", "full", "ultra"]);
+const DEFAULT_MODE = "full";
+const ROOT = path.resolve(__dirname, "..");
+
+class InvalidModeError extends Error {
+  constructor(value) {
+    super(`Invalid Necktie mode: ${String(value)}. Expected lite, full, or ultra.`);
+    this.name = "InvalidModeError";
+    this.code = "NECKTIE_INVALID_MODE";
+  }
+}
+
+function normalizeMode(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return MODES.includes(normalized) ? normalized : null;
+}
+
+function configPath(env = process.env, options = {}) {
+  if (options.configPath) return path.resolve(options.configPath);
+  const platform = options.platform || process.platform;
+  const home = options.home || os.homedir();
+  if (platform === "win32") {
+    const base = env.APPDATA || path.win32.join(home, "AppData", "Roaming");
+    return path.win32.join(base, "necktie", "config.json");
+  }
+  if (env.XDG_CONFIG_HOME) return path.join(env.XDG_CONFIG_HOME, "necktie", "config.json");
+  return path.join(home, ".config", "necktie", "config.json");
+}
+
+function readConfig(env = process.env, options = {}) {
+  const target = configPath(env, options);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(target, "utf8").replace(/^\uFEFF/, ""));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { config: {}, warning: `Ignored non-object Necktie configuration at ${target}.`, path: target };
+    }
+    return { config: parsed, warning: null, path: target };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { config: {}, warning: null, path: target };
+    return { config: {}, warning: `Ignored invalid Necktie configuration at ${target}.`, path: target };
+  }
+}
+
+function resolveDefaultMode(env = process.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 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}.`);
+    }
+  }
+
+  return {
+    mode: environmentMode || configuredMode,
+    source: environmentMode ? "environment" : configuredSource,
+    configuredMode,
+    configuredSource,
+    environmentOverride: environmentMode,
+    configPath: loaded.path,
+    warnings,
+  };
+}
+
+function resolveMode({ requestedMode, sessionMode, env = process.env, configOptions = {} } = {}) {
+  const defaultResolution = resolveDefaultMode(env, configOptions);
+  const warnings = [...defaultResolution.warnings];
+
+  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 !== "") {
+    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,
+      };
+    }
+    warnings.push(`Ignored invalid stored Necktie session mode: ${String(sessionMode)}.`);
+  }
+
+  return {
+    mode: defaultResolution.mode,
+    source: defaultResolution.source,
+    defaultMode: defaultResolution.mode,
+    defaultSource: defaultResolution.source,
+    configuredDefaultMode: defaultResolution.configuredMode,
+    configuredDefaultSource: defaultResolution.configuredSource,
+    environmentOverride: defaultResolution.environmentOverride,
+    configPath: defaultResolution.configPath,
+    warnings,
+  };
+}
+
+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;
+  return fs.readFileSync(path.join(root, "core", `necktie-${normalized}.md`), "utf8")
+    .replace(/^\uFEFF/, "")
+    .replace(/\r\n?/g, "\n")
+    .trim();
+}
+
+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 (_) {}
+  }
+  return {
+    writtenMode: normalized,
+    ...resolveDefaultMode(env, options),
+  };
+}
+
+module.exports = {
+  DEFAULT_MODE,
+  InvalidModeError,
+  MODES,
+  buildInstructions,
+  configPath,
+  normalizeMode,
+  readConfig,
+  resolveDefaultMode,
+  resolveMode,
+  writeDefaultMode,
+};

package/lib/necktie-session.cjs

@@ -0,0 +1,87 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const { normalizeMode } = require("./necktie-policy.cjs");
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+function stateDirectory(options = {}) {
+  return path.resolve(options.stateDirectory || path.join(os.tmpdir(), "necktie", "sessions"));
+}
+
+function sessionIdentifier(input = {}, env = process.env, options = {}) {
+  const candidates = [
+    input.session_id,
+    input.sessionId,
+    input.sessionID,
+    input.thread_id,
+    input.threadId,
+    env.CODEX_THREAD_ID,
+    env.CLAUDE_SESSION_ID,
+    env.COPILOT_SESSION_ID,
+    env.QODER_SESSION_ID,
+    options.fallbackId,
+  ];
+  const found = candidates.find((value) => typeof value === "string" && value.trim());
+  return found ? found.trim() : `parent-${options.parentPid || process.ppid}`;
+}
+
+function statePath(host, sessionId, options = {}) {
+  const digest = crypto.createHash("sha256").update(`${host}\0${sessionId}`).digest("hex");
+  return path.join(stateDirectory(options), `${host}-${digest}.json`);
+}
+
+function prune(options = {}) {
+  const directory = stateDirectory(options);
+  let entries;
+  try { entries = fs.readdirSync(directory, { withFileTypes: true }); } catch (_) { return; }
+  const now = options.now || Date.now();
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const target = path.join(directory, entry.name);
+    try {
+      if (now - fs.statSync(target).mtimeMs > MAX_AGE_MS) fs.unlinkSync(target);
+    } catch (_) {}
+  }
+}
+
+function readSessionMode(host, sessionId, options = {}) {
+  prune(options);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(statePath(host, sessionId, options), "utf8"));
+    return typeof parsed?.mode === "string" ? parsed.mode : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+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 (_) {}
+  }
+  return normalized;
+}
+
+module.exports = {
+  MAX_AGE_MS,
+  prune,
+  readSessionMode,
+  sessionIdentifier,
+  stateDirectory,
+  statePath,
+  writeSessionMode,
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@gillcash/necktie",
-  "version": "0.2.0",
-  "description": "The angel of late-stage capitalism for your AI agent: an always-on response check and an explicit bounded review loop.",
-  "keywords": ["agent-plugin", "agent-loop", "prompt-reversal", "review", "verification"],
+  "version": "0.4.0",
+  "description": "The angel of late-stage capitalism for your AI agent, with Mammon as its internal adversary.",
+  "keywords": ["agent-plugin", "incentives", "power", "externalities", "opinionated-agent"],
   "license": "MIT",
   "author": {
     "name": "gillcash",
@@ -25,9 +25,11 @@
     "AGENTS.md",
     "plugin.json",
     "core/",
+    "lib/",
     "hooks/",
     "skills/",
     "commands/",
+    "docs/",
     ".opencode/",
     ".qoder/",
     ".qoder-plugin/",
@@ -40,8 +42,10 @@
     "!pi-extension/test/**"
   ],
   "scripts": {
-    "build:adapters": "node scripts/build-adapters.js && node scripts/build-openclaw-skills.js",
-    "check:adapters": "node scripts/build-adapters.js --check",
+    "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",
     "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"
   },

package/pi-extension/index.js

@@ -1,11 +1,27 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+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() {
-  return fs.readFileSync(path.resolve(__dirname, "..", "core", "necktie-core.md"), "utf8").trim();
+export function coreContext(mode = DEFAULT_MODE) {
+  return buildInstructions(mode);
+}
+
+export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  const fallback = normalizeMode(fallbackMode) || DEFAULT_MODE;
+  if (!Array.isArray(entries)) return fallback;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.type !== "custom" || entry?.customType !== "necktie-mode") continue;
+    const mode = normalizeMode(entry?.data?.mode);
+    if (mode) return mode;
+  }
+  return fallback;
+}
+
+export function parseNecktieModeCommand(text) {
+  return parseModeArguments(text);
 }
 
 export function sendSkill(pi, skill, args, ctx) {
@@ -16,14 +32,56 @@ export function sendSkill(pi, skill, args, ctx) {
 }
 
 export default function necktieExtension(pi) {
-  for (const skill of ["necktie", "necktie-critique", "necktie-reverse", "necktie-review"]) {
-    pi.registerCommand(skill, {
-      description: `Run /skill:${skill}`,
-      handler: (args, ctx) => sendSkill(pi, skill, args, ctx),
-    });
-  }
+  let configuredDefault = resolveMode();
+  let currentMode = configuredDefault.mode;
+
+  pi.registerCommand("necktie", {
+    description: "Run /skill:necktie",
+    handler: (args, ctx) => sendSkill(pi, "necktie", args, ctx),
+  });
+
+  pi.registerCommand("necktie-mode", {
+    description: "Set Necktie mode: lite, full, or ultra. 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;
+      }
+      ctx?.ui?.notify?.(message, parsed.type === "invalid" ? "warning" : "info");
+      return message;
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    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);
+  });
+
   pi.on("before_agent_start", async (event) => {
     const base = event?.systemPrompt ? `${event.systemPrompt}\n\n` : "";
-    return { systemPrompt: `${base}${coreContext()}` };
+    return { systemPrompt: `${base}${coreContext(currentMode)}` };
   });
 }

package/pi-extension/package.json

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

package/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "necktie",
-  "version": "0.2.0",
-  "description": "The angel of late-stage capitalism for your AI agent: an always-on response check and an explicit bounded review loop.",
+  "version": "0.4.0",
+  "description": "The angel of late-stage capitalism for your AI agent, with Mammon as its internal adversary.",
   "author": {
     "name": "gillcash",
     "url": "https://github.com/gillcash"
@@ -10,5 +10,5 @@
   "homepage": "https://github.com/gillcash/necktie",
   "repository": "https://github.com/gillcash/necktie",
   "license": "MIT",
-  "keywords": ["agent-loop", "prompt-reversal", "review", "verification"]
+  "keywords": ["incentives", "power", "externalities", "opinionated-agent"]
 }