portable-agent-layer 0.35.0 → 0.37.0

package/src/cli/setup-telos.ts

@@ -1,78 +1,14 @@
 /**
  * Interactive TELOS setup — prompts for personal context during `pal install`.
  * Skips any step whose TELOS file already has real content.
- * Projects use the upsertProject tool directly with a structured add-another loop.
  */
 
 import { writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import * as clack from "@clack/prompts";
-import { upsertProject } from "../../assets/skills/telos/tools/update-projects";
 import { palHome } from "../hooks/lib/paths";
 import { hasRealContent, SETUP_STEPS, STEP_ORDER } from "../hooks/lib/setup";
 
-function toKebabCase(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "");
-}
-
-async function promptProjectsLoop(): Promise<void> {
-  const addFirst = await clack.confirm({
-    message: "Do you want to add any projects now?",
-    initialValue: true,
-  });
-  if (clack.isCancel(addFirst) || !addFirst) return;
-
-  let addMore = true;
-  while (addMore) {
-    const name = await clack.text({
-      message: "Project name?",
-      placeholder: "e.g. PAL, My SaaS, Work Dashboard",
-    });
-    if (clack.isCancel(name)) return;
-
-    const status = await clack.select({
-      message: "Status?",
-      options: [
-        { value: "Active", label: "Active" },
-        { value: "Planning", label: "Planning" },
-        { value: "Paused", label: "Paused" },
-        { value: "Complete", label: "Complete" },
-      ],
-    });
-    if (clack.isCancel(status)) return;
-
-    const priority = await clack.select({
-      message: "Priority?",
-      options: [
-        { value: "High", label: "High" },
-        { value: "Medium", label: "Medium" },
-        { value: "Low", label: "Low" },
-      ],
-    });
-    if (clack.isCancel(priority)) return;
-
-    const notes = await clack.text({
-      message: "Notes? (optional — leave blank to skip)",
-      placeholder: "e.g. Building the v2 API, blocked on design review",
-    });
-    if (clack.isCancel(notes)) return;
-
-    const id = toKebabCase(name as string);
-    const row = `| ${id} | ${name} | ${status} | ${priority} | ${notes || ""} |`;
-    upsertProject(id, row, `Added ${name} during PAL setup`);
-    clack.log.success(`Added: ${name}`);
-
-    const again = await clack.confirm({
-      message: "Add another project?",
-      initialValue: false,
-    });
-    if (clack.isCancel(again) || !again) addMore = false;
-  }
-}
-
 /** Prompt for missing TELOS context. Skips any step whose file already has real content. */
 export async function promptTelos(): Promise<void> {
   // Skip interactive prompts in non-TTY environments (tests, CI)
@@ -95,25 +31,21 @@ export async function promptTelos(): Promise<void> {
   );
 
   for (const key of pending) {
-    if (key === "projects") {
-      await promptProjectsLoop();
-    } else {
-      const step = SETUP_STEPS[key];
-      const title = key.charAt(0).toUpperCase() + key.slice(1);
-
-      const answer = await clack.text({
-        message: step.question,
-        placeholder: step.hint,
-      });
+    const step = SETUP_STEPS[key];
+    const title = key.charAt(0).toUpperCase() + key.slice(1);
 
-      if (clack.isCancel(answer)) {
-        clack.cancel("Setup cancelled");
-        return;
-      }
+    const answer = await clack.text({
+      message: step.question,
+      placeholder: step.hint,
+    });
 
-      const filePath = resolve(home, step.file);
-      writeFileSync(filePath, `# ${title}\n\n${answer}\n`, "utf-8");
+    if (clack.isCancel(answer)) {
+      clack.cancel("Setup cancelled");
+      return;
     }
+
+    const filePath = resolve(home, step.file);
+    writeFileSync(filePath, `# ${title}\n\n${answer}\n`, "utf-8");
   }
 
   clack.outro("Personal context saved ✓");

package/src/hooks/CompactRecover.ts

@@ -8,8 +8,10 @@
  * Storage: ~/.pal/memory/state/last-exchange/{session_id}.json (with latest.json fallback).
  */
 
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { readFile, unlink } from "node:fs/promises";
 import { resolve } from "node:path";
+import { isCursor } from "./lib/agent";
 import { logDebug, logError } from "./lib/log";
 import { paths } from "./lib/paths";
 import { readStdinJSON } from "./lib/stdin";
@@ -61,7 +63,7 @@ const main = async () => {
       process.exit(0);
     }
 
-    const saved = JSON.parse(readFileSync(file, "utf-8")) as SavedExchange;
+    const saved = JSON.parse(await readFile(file, "utf-8")) as SavedExchange;
     const userBudget = Math.floor(MAX_OUTPUT * 0.4);
     const assistantBudget = MAX_OUTPUT - userBudget - 300; // reserve for framing
 
@@ -81,7 +83,11 @@ const main = async () => {
       "</system-reminder>",
     ].join("\n");
 
-    process.stdout.write(out);
+    if (isCursor()) {
+      process.stdout.write(JSON.stringify({ additional_context: out }));
+    } else {
+      process.stdout.write(out);
+    }
     logDebug("CompactRecover", `Re-injected ${out.length} chars from ${file}`);
 
     // Consume-on-read: drop the session-keyed file after a successful injection so it
@@ -90,7 +96,7 @@ const main = async () => {
     const sessionFile = sessionId ? resolve(stateDir, `${sessionId}.json`) : null;
     if (sessionFile && file === sessionFile) {
       try {
-        unlinkSync(sessionFile);
+        await unlink(sessionFile);
       } catch (err) {
         logError("CompactRecover:cleanup", err);
       }
@@ -102,4 +108,4 @@ const main = async () => {
   process.exit(0);
 };
 
-main();
+await main();

package/src/hooks/LoadContext.ts

@@ -9,10 +9,10 @@
  * context directly to ~/.copilot/copilot-instructions.md so it is picked up on load.
  */
 
-import { existsSync, lstatSync, unlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { buildClaudeMd, regenerateIfNeeded } from "./lib/claude-md";
-import { buildSystemReminder } from "./lib/context";
+import { type AgentTarget, buildSystemReminder } from "./lib/context";
 import { logDebug, logError } from "./lib/log";
 import { platform } from "./lib/paths";
 
@@ -36,25 +36,49 @@ try {
 
 // --- Context to stdout (or file for Copilot) ---
 try {
-  const reminder = buildSystemReminder();
+  // Determine agent target — controls which sections are skipped (loaded natively instead).
+  let agent: AgentTarget = "claude";
+  if (process.env.PAL_AGENT === "copilot") agent = "copilot";
+  else if (process.env.PAL_AGENT === "cursor" || process.env.CURSOR_VERSION)
+    agent = "cursor";
+  const reminder = buildSystemReminder({ agent });
   if (!reminder) process.exit(0);
 
   if (process.env.PAL_AGENT === "copilot") {
-    // Copilot: sessionStart output is ignored — write merged context to copilot-instructions.md
-    const instructionsPath = resolve(platform.copilotDir(), "copilot-instructions.md");
+    // Copilot: semi-static in ~/.copilot/instructions/pal-*.instructions.md (written at stop).
+    // Write AGENTS.md + dynamic context to pal-session.instructions.md on each session start.
+    const instructionsDir = resolve(platform.copilotDir(), "instructions");
+    mkdirSync(instructionsDir, { recursive: true });
     const agentsMd = buildClaudeMd();
     const context = [agentsMd, reminder].filter(Boolean).join("\n\n");
-    if (existsSync(instructionsPath) && lstatSync(instructionsPath).isSymbolicLink()) {
-      unlinkSync(instructionsPath);
+    if (context) {
+      writeFileSync(
+        resolve(instructionsDir, "pal-session.instructions.md"),
+        `---\napplyTo: "**"\n---\n\n${context}`,
+        "utf-8"
+      );
     }
-    writeFileSync(instructionsPath, context, "utf-8");
-    logDebug("LoadContext", `Copilot instructions written: ${context.length} chars`);
-  } else if (process.env.CURSOR_VERSION) {
-    // Cursor: no native user-level rules — inject AGENTS.md + dynamic context
+    logDebug(
+      "LoadContext",
+      `Copilot session instructions written: ${context.length} chars`
+    );
+  } else if (process.env.PAL_AGENT === "cursor" || process.env.CURSOR_VERSION) {
+    // Cursor: semi-static in ~/.cursor/rules/pal-context.mdc; inject AGENTS.md + dynamic here
     const agentsMd = buildClaudeMd();
     const context = [agentsMd, reminder].filter(Boolean).join("\n\n");
     process.stdout.write(JSON.stringify({ additional_context: context }));
     logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
+  } else if (process.env.PAL_AGENT === "codex") {
+    // Codex: AGENTS.md already loaded via symlink; inject only dynamic context
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: reminder,
+        },
+      })
+    );
+    logDebug("LoadContext", `Codex reminder injected: ${reminder.length} chars`);
   } else {
     // Claude Code: raw text
     console.log(reminder);

package/src/hooks/PreCompactPersist.ts

@@ -11,17 +11,14 @@
  * is currently a Claude Code event.
  */
 
-import { writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
+import { persistLastExchange } from "./handlers/persist-last-exchange";
 import { logDebug, logError } from "./lib/log";
-import { ensureDir, paths } from "./lib/paths";
+import { paths } from "./lib/paths";
 import { readStdinJSON } from "./lib/stdin";
-import {
-  extractContent,
-  extractLastAssistant,
-  extractLastUser,
-  readTranscriptFile,
-} from "./lib/transcript";
+import { readTranscriptFile } from "./lib/transcript";
 
 interface PreCompactInput {
   session_id?: string;
@@ -45,36 +42,31 @@ const main = async () => {
       logDebug("PreCompactPersist", "Transcript empty or unreadable");
       process.exit(0);
     }
+    const sessionId = input.session_id ?? "unknown";
+    const cwd = input.cwd ?? process.cwd();
 
-    const lastUser = extractContent(extractLastUser(messages));
-    const lastAssistant = extractContent(extractLastAssistant(messages));
-
-    if (!lastUser && !lastAssistant) {
-      logDebug("PreCompactPersist", "No user/assistant text found in transcript");
-      process.exit(0);
+    // Stop fires after every response and is authoritative. Skip if it already
+    // wrote latest.json for this session — PreCompact is a safety net only.
+    const latestPath = resolve(paths.state(), "last-exchange", "latest.json");
+    if (existsSync(latestPath)) {
+      try {
+        const latest = JSON.parse(await readFile(latestPath, "utf-8"));
+        if (latest?.sessionId === sessionId) {
+          logDebug(
+            "PreCompactPersist",
+            `Stop already persisted session ${sessionId} — skipping`
+          );
+          process.exit(0);
+        }
+      } catch {
+        /* unreadable — fall through and write */
+      }
     }
 
-    const sessionId = input.session_id || "unknown";
-    const payload = {
-      sessionId,
-      timestamp: new Date().toISOString(),
-      trigger: input.trigger ?? null,
-      customInstructions: input.custom_instructions || null,
-      userMessage: lastUser,
-      assistantMessage: lastAssistant,
-    };
-
-    const stateDir = ensureDir(resolve(paths.state(), "last-exchange"));
-    const sessionFile = resolve(stateDir, `${sessionId}.json`);
-    const latestFile = resolve(stateDir, "latest.json");
-    const json = `${JSON.stringify(payload, null, 2)}\n`;
-
-    writeFileSync(sessionFile, json, "utf-8");
-    writeFileSync(latestFile, json, "utf-8");
-
+    persistLastExchange(messages, sessionId, cwd);
     logDebug(
       "PreCompactPersist",
-      `Saved last exchange (user=${lastUser.length}ch, assistant=${lastAssistant.length}ch) for session ${sessionId}`
+      `Persisted exchange before compaction for session ${sessionId}`
     );
   } catch (err) {
     logError("PreCompactPersist", err);
@@ -83,4 +75,4 @@ const main = async () => {
   process.exit(0);
 };
 
-main();
+await main();

package/src/hooks/SecurityValidator.ts

@@ -6,47 +6,69 @@
  */
 
 import { blockResponse } from "./lib/agent";
-import { checkBashCommand, checkFilePath, WARN_COMMANDS } from "./lib/security";
+import { checkBashCommand, checkFilePath } from "./lib/security";
 import { readStdinJSON } from "./lib/stdin";
 
+// preToolUse shape (Claude Code + Cursor + Codex)
 interface ToolUseInput {
   tool_name: string;
+  hook_event_name?: string; // Codex includes this in all hook inputs
   tool_input: {
     command?: string;
     file_path?: string;
   };
 }
 
-try {
-  const input = await readStdinJSON<ToolUseInput>();
-  if (!input) process.exit(0);
+// beforeShellExecution shape (Cursor only) — flat, no tool_name wrapper
+interface ShellExecInput {
+  command: string;
+  sandbox?: boolean;
+}
 
-  const { tool_name, tool_input } = input;
+type SecurityInput = ToolUseInput | ShellExecInput;
 
-  // Normalize tool names: Claude uses "Bash", Cursor uses "Shell"
-  const isBash = tool_name === "Bash" || tool_name === "Shell";
-  const isFileWrite = tool_name === "Write" || tool_name === "Edit";
+function isShellExec(input: SecurityInput): input is ShellExecInput {
+  return !("tool_name" in input) && "command" in input;
+}
+
+try {
+  const input = await readStdinJSON<SecurityInput>();
+  if (!input) process.exit(0);
 
-  // Check shell commands
-  if (isBash && tool_input.command) {
-    const reason = checkBashCommand(tool_input.command);
+  if (isShellExec(input)) {
+    // beforeShellExecution — command is always a shell command
+    const reason = checkBashCommand(input.command);
     if (reason) {
       process.stdout.write(blockResponse(`Blocked: ${reason}`));
-      process.exit(0);
     }
+    process.exit(0);
+  }
+
+  const hookEventName = input.hook_event_name;
+
+  // preToolUse — Claude: "Bash", Cursor: "Shell", Codex: "shell"
+  const isBash =
+    input.tool_name === "Bash" ||
+    input.tool_name === "Shell" ||
+    input.tool_name === "shell";
+  const isFileWrite =
+    input.tool_name === "Write" ||
+    input.tool_name === "Edit" ||
+    input.tool_name === "write_file" ||
+    input.tool_name === "apply_patch";
 
-    for (const pattern of WARN_COMMANDS) {
-      if (pattern.test(tool_input.command)) {
-        break;
-      }
+  if (isBash && input.tool_input.command) {
+    const reason = checkBashCommand(input.tool_input.command);
+    if (reason) {
+      process.stdout.write(blockResponse(`Blocked: ${reason}`, hookEventName));
+      process.exit(0);
     }
   }
 
-  // Check file path operations
-  if (isFileWrite && tool_input.file_path) {
-    const fileReason = checkFilePath(tool_input.file_path);
-    if (fileReason) {
-      process.stdout.write(blockResponse(fileReason));
+  if (isFileWrite && input.tool_input.file_path) {
+    const reason = checkFilePath(input.tool_input.file_path);
+    if (reason) {
+      process.stdout.write(blockResponse(reason, hookEventName));
       process.exit(0);
     }
   }

package/src/hooks/StopOrchestrator.ts

@@ -7,7 +7,7 @@
  */
 
 import { checkReadmeSync } from "./handlers/readme-sync";
-import { isCursor } from "./lib/agent";
+import { isCodex, isCursor } from "./lib/agent";
 import { logError } from "./lib/log";
 import { readStdinJSON } from "./lib/stdin";
 import { runStopHandlers } from "./lib/stop";
@@ -26,6 +26,9 @@ try {
     if (isCursor()) {
       // Cursor stop hook: followup_message auto-sends to the agent
       process.stdout.write(JSON.stringify({ followup_message: decision.reason }));
+    } else if (isCodex()) {
+      // Codex stop hook: additionalContext re-queues as next prompt
+      process.stdout.write(JSON.stringify({ additionalContext: decision.reason }));
     } else {
       // Claude Code: block decision
       process.stdout.write(JSON.stringify(decision));

package/src/hooks/UserPromptOrchestrator.ts

@@ -16,15 +16,17 @@ import { readStdinJSON } from "./lib/stdin";
 interface PromptSubmitInput {
   prompt: string;
   session_id?: string;
+  conversation_id?: string; // Cursor sends this instead of session_id
 }
 
 const input = await readStdinJSON<PromptSubmitInput>();
 logDebug("UserPromptOrchestrator", `Input: ${JSON.stringify(input).slice(0, 200)}`);
 if (!input?.prompt) process.exit(0);
 
+const sessionId = input.session_id ?? input.conversation_id;
 const results = await Promise.allSettled([
-  captureRating(input.prompt, input.session_id),
-  captureSessionName(input.prompt, input.session_id ?? ""),
+  captureRating(input.prompt, sessionId),
+  captureSessionName(input.prompt, sessionId ?? ""),
   injectRetrieval(input.prompt),
 ]);
 

package/src/hooks/handlers/auto-graduate.ts

@@ -77,12 +77,12 @@ function alreadyPromoted(state: GraduationState, pattern: string): boolean {
   return state.graduated.some((g) => g.pattern === pattern);
 }
 
-export interface AutoGraduateOptions {
+interface AutoGraduateOptions {
   /** Bypass the 24h TTL guard. State + content dedup still apply. */
   force?: boolean;
 }
 
-export interface AutoGraduateResult {
+interface AutoGraduateResult {
   ranAnalysis: boolean;
   candidatesAtFloor: number;
   promoted: number;

package/src/hooks/handlers/backup.ts

@@ -4,7 +4,7 @@
  * is older than 7 days, or if no backup exists yet.
  */
 
-import { readdirSync, statSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { exportZip, timestamp } from "../lib/export";
 import { logDebug } from "../lib/log";
@@ -16,14 +16,14 @@ export async function autoBackup(): Promise<void> {
   const backupDir = paths.backups();
 
   // Check most recent backup
-  const existing = readdirSync(backupDir)
+  const existing = (await readdir(backupDir))
     .filter((f) => f.startsWith("pal-backup-") && f.endsWith(".zip"))
     .sort()
     .reverse();
 
   if (existing.length > 0) {
     const latestPath = resolve(backupDir, existing[0]);
-    const latestMtime = statSync(latestPath).mtimeMs;
+    const latestMtime = (await stat(latestPath)).mtimeMs;
     if (Date.now() - latestMtime < BACKUP_INTERVAL_MS) {
       logDebug("backup", "Skipping — last backup is less than 7 days old");
       return;

package/src/hooks/handlers/context-digests.ts

@@ -0,0 +1,74 @@
+/**
+ * Handler: write pre-compiled context digest files for @import / instructions[].
+ *
+ * Runs at session stop so that CLAUDE.md can @import these files natively
+ * at the next session start, keeping hook stdout small.
+ *
+ * Sources are defined in src/hooks/lib/semi-static.ts — add one entry there
+ * to extend coverage to all consumers (CLAUDE.md, opencode, Cursor, Copilot).
+ */
+
+import { existsSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { ensureDir, platform } from "../lib/paths";
+import {
+  copilotFilename,
+  cursorFilename,
+  getSemiStaticSources,
+} from "../lib/semi-static";
+
+export function writeContextDigests(): void {
+  const sources = getSemiStaticSources();
+
+  // Resolve Cursor/Copilot destination dirs once (null if agent not installed)
+  let rulesDir: string | null = null;
+  let instructionsDir: string | null = null;
+
+  try {
+    const cursorDir = platform.cursorDir();
+    if (existsSync(cursorDir)) {
+      rulesDir = ensureDir(resolve(cursorDir, "rules"));
+    }
+  } catch {
+    /* non-fatal */
+  }
+
+  try {
+    const copilotDir = platform.copilotDir();
+    if (existsSync(copilotDir)) {
+      instructionsDir = ensureDir(resolve(copilotDir, "instructions"));
+    }
+  } catch {
+    /* non-fatal */
+  }
+
+  for (const src of sources) {
+    try {
+      const content = src.load();
+      if (!content) continue;
+
+      if (src.writesDigest) {
+        ensureDir(dirname(src.path));
+        writeFileSync(src.path, content, "utf-8");
+      }
+
+      if (rulesDir) {
+        writeFileSync(
+          resolve(rulesDir, cursorFilename(src)),
+          `---\ndescription: ${src.description}\nalwaysApply: true\n---\n\n${content}`,
+          "utf-8"
+        );
+      }
+
+      if (instructionsDir) {
+        writeFileSync(
+          resolve(instructionsDir, copilotFilename(src)),
+          `---\napplyTo: "**"\n---\n\n${content}`,
+          "utf-8"
+        );
+      }
+    } catch {
+      /* non-fatal */
+    }
+  }
+}

package/src/hooks/handlers/failure.ts

@@ -7,7 +7,7 @@
  * Analysis is left to the human or the graduation pipeline, not auto-generated.
  */
 
-import { writeFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { stringify } from "../lib/frontmatter";
 import { ensureDir, paths } from "../lib/paths";
@@ -31,7 +31,8 @@ export async function captureFailure(
   context: string,
   transcript: string,
   detailedContext?: string,
-  principle?: string
+  principle?: string,
+  cwd?: string
 ): Promise<void> {
   const messages = parseMessages(transcript);
 
@@ -57,6 +58,7 @@ export async function captureFailure(
     slug,
   };
   if (principle) meta.principle = principle;
+  if (cwd) meta.cwd = cwd;
 
   const body = [
     "## What Happened",
@@ -69,5 +71,5 @@ export async function captureFailure(
     conversationSummary || "*(unavailable)*",
   ].join("\n");
 
-  writeFileSync(resolve(dir, "capture.md"), stringify(meta, body), "utf-8");
+  await writeFile(resolve(dir, "capture.md"), stringify(meta, body), "utf-8");
 }

package/src/hooks/handlers/inject-retrieval.ts

@@ -7,6 +7,7 @@
  * timeout produces empty output, never blocks the prompt.
  */
 
+import { isCodex, isCursor } from "../lib/agent";
 import { logDebug, logError } from "../lib/log";
 import { runRetrieval } from "../lib/retrieval";
 import { ensureIndex } from "../lib/retrieval-index";
@@ -29,9 +30,10 @@ function withTimeout<T>(work: () => T, ms: number): Promise<T | null> {
   });
 }
 
-export async function injectRetrieval(prompt: string): Promise<void> {
-  if (!prompt?.trim()) return;
-  if (!isEnabled("learningInjection")) return;
+/** Returns the retrieval reminder string, or null if nothing to inject. @lintignore dynamically imported by opencode plugin */
+export async function getRetrievalReminder(prompt: string): Promise<string | null> {
+  if (!prompt?.trim()) return null;
+  if (!isEnabled("learningInjection")) return null;
 
   const result = await withTimeout(() => {
     const index = ensureIndex();
@@ -39,12 +41,33 @@ export async function injectRetrieval(prompt: string): Promise<void> {
     return runRetrieval(prompt, index, process.cwd());
   }, TIMEOUT_MS);
 
-  if (!result?.reminder) return;
+  if (!result?.reminder) return null;
 
   logDebug(
     "inject-retrieval",
-    `injected ${result.matches.length} matches; top score=${result.matches[0]?.confidence.toFixed(3)}`
+    `${result.matches.length} matches; top score=${result.matches[0]?.confidence.toFixed(3)}`
   );
 
-  process.stdout.write(`${result.reminder}\n`);
+  return result.reminder;
+}
+
+/** Write retrieval reminder to stdout in the correct format for the current agent.
+ *  Claude Code: plain text. Cursor: { additional_context }. Codex: hookSpecificOutput JSON. */
+export async function injectRetrieval(prompt: string): Promise<void> {
+  const reminder = await getRetrievalReminder(prompt);
+  if (!reminder) return;
+  if (isCursor()) {
+    process.stdout.write(JSON.stringify({ additional_context: reminder }));
+  } else if (isCodex()) {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: reminder,
+        },
+      })
+    );
+  } else {
+    process.stdout.write(`${reminder}\n`);
+  }
 }