@empirical-gauzza/cli 1.0.32 → 1.0.34

package/lib/alertBanner.js

@@ -23,6 +23,16 @@ function colorize(code, text) {
   return `${code}${text}${ANSI.reset}`;
 }
 
+// Due times are shown in this terminal's own time zone, never the server's UTC sentence.
+function localDueLine(alert) {
+  if (!alert || !alert.dueAt) return alert ? alert.body : '';
+  const d = new Date(alert.dueAt);
+  if (Number.isNaN(d.getTime())) return alert.body;
+  const when = d.toLocaleString(undefined, { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZoneName: 'short' });
+  const rest = String(alert.body || '').replace(/^Due [^\n]*? UTC\.\s*/, '');
+  return `Due ${when}.${rest ? ` ${rest}` : ''}`;
+}
+
 function reminderMemoryId(alert) {
   const key = String(alert && alert.alertKey || '');
   return key.startsWith('reminder_') ? key.slice('reminder_'.length) : null;
@@ -37,7 +47,7 @@ function renderOneAlert(alert) {
     // A reminder the user set. Whoever reads this, person or agent, should surface it first;
     // the agent case was observed being skipped when the banner read like a footnote.
     lines.push(colorize(`${ANSI.bold}${color}`, `REMINDER DUE - tell the user now: ${alert.title.replace(/^Reminder:\s*/, '')}`));
-    lines.push(`  ${alert.body}`);
+    lines.push(`  ${localDueLine(alert)}`);
     for (const action of alert.actions || []) {
       lines.push(`  → ${action.label}: ${action.href}`);
     }

package/lib/doctor.js

@@ -156,7 +156,7 @@ function claudeHookStatus() {
       && entry.hooks.some((h) => h && typeof h.command === 'string' && h.command.includes(hooksDir)));
   });
 
-  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: settingsPath };
+  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: settingsPath, registeredEvents };
 }
 
 function codexHookStatus() {
@@ -174,24 +174,30 @@ function codexHookStatus() {
       && entry.hooks.some((h) => h && typeof h.command === 'string' && h.command.includes(hooksDir)));
   });
 
-  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: hooksJsonPath };
+  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: hooksJsonPath, registeredEvents };
 }
 
+// SessionStart only (2026-09-18): Copilot's agentStop reminder hook was removed entirely (recording
+// stays instructions-only via copilot-instructions.md), and its UserPromptSubmit real-recall hook
+// was ALSO removed after confirming live that Copilot renders modifiedPrompt back as the user's own
+// visible message - not acceptable for silent recall. Real recall moved to sessionStart's
+// additionalContext instead (re-confirmed against GitHub's current hooks reference that this event
+// supports it for command hooks), so sessionStart is once again the only event expected/checked.
 function copilotHookStatus() {
   const hooksDir = getEmpiricalHooksDir();
-  const scripts = ['copilot-session-start.js', 'copilot-user-prompt-submit.js', 'copilot-stop.js'];
+  const scripts = ['copilot-session-start.js'];
   const missingScripts = scripts.filter((name) => !readUtf8IfExists(path.join(hooksDir, name)));
 
   const hookFilePath = path.join(os.homedir(), '.copilot', 'hooks', 'empirical-hooks.json');
   const hookFile = readJsonIfExists(hookFilePath) || {};
-  const hookEvents = ['sessionStart', 'userPromptSubmitted', 'agentStop'];
+  const hookEvents = ['sessionStart'];
   const registeredEvents = hookEvents.filter((eventName) => {
     const entries = hookFile.hooks && hookFile.hooks[eventName];
     if (!Array.isArray(entries)) return false;
     return entries.some((h) => h && typeof h.command === 'string' && h.command.includes(hooksDir));
   });
 
-  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: hookFilePath };
+  return { missingScripts, missingRegistrations: hookEvents.filter((e) => !registeredEvents.includes(e)), manifestPath: hookFilePath, registeredEvents };
 }
 
 const HOOK_STATUS_CHECKERS = {
@@ -495,7 +501,12 @@ async function runDoctor(args) {
         continue;
       }
       if (status.missingScripts.length === 0 && status.missingRegistrations.length === 0) {
-        addCheck(`hooks_${target.id}`, 'ok', `${target.label}: SessionStart/UserPromptSubmit/Stop hook scripts present and registered in ${status.manifestPath}.`);
+        // status.registeredEvents (not a hardcoded event list) so this stays accurate per host -
+        // Copilot only registers sessionStart now (2026-09-18: userPromptSubmitted/agentStop
+        // reminder hooks were removed, see copilotHookStatus's comment), while Claude/Codex still
+        // register all three.
+        const eventList = (status.registeredEvents || []).join('/') || 'hook';
+        addCheck(`hooks_${target.id}`, 'ok', `${target.label}: ${eventList} hook script(s) present and registered in ${status.manifestPath}.`);
       } else {
         const parts = [];
         if (status.missingScripts.length) parts.push(`missing script file(s): ${status.missingScripts.join(', ')}`);

package/lib/installers/coreMemoryBlock.js

@@ -35,10 +35,22 @@ function describePlugin(name) {
  * run actually installed, not a static "here's everything that could exist" list, so it stays
  * accurate as skills are added or removed on a later `empirical install`/`empirical plugin` run.
  */
-function buildCoreMemoryBlock({ pluginNames = [CORE_PLUGIN_NAME] } = {}) {
+function buildCoreMemoryBlock({ pluginNames = [CORE_PLUGIN_NAME], hostId } = {}) {
   const names = Array.isArray(pluginNames) && pluginNames.length ? pluginNames : [CORE_PLUGIN_NAME];
   const skillLines = names.map((name) => `- \`${name}\` - ${describePlugin(name)}`).join('\n');
 
+  // Copilot-only (2026-09-18): Copilot's hook events can't carry a passive reminder the way
+  // Claude/Codex's can (agentStop only supports decision:"block"|"allow" - see COPILOT_HOOK_STOP_SOURCE's
+  // removal in hooks.js), and Copilot has no reminder hooks installed at all as a result. This is
+  // the ONLY mechanism left nudging Copilot toward Empirical, so it has to be explicit and
+  // directive rather than assume a hook will catch what this misses.
+  const copilotAddendum = hostId === 'copilot'
+    ? `\n\nThis host has no reminder hook wired up for Empirical (a platform limitation, not an
+oversight) - this instructions file is the only thing that will ever prompt you to use it. Query
+and record proactively, on your own initiative, without waiting to be asked or reminded. Do this
+before ending a turn where you completed meaningful work, not just when explicitly told to.`
+    : '';
+
   return `${BEGIN_MARKER}
 ## Persistent memory: Empirical
 
@@ -61,7 +73,7 @@ session notes into answers about the user's own life.
 Installed Empirical skills in this environment:
 ${skillLines}
 
-Run \`empirical doc\` for the full command reference, or \`empirical doc memory\` for exact query/record syntax.
+Run \`empirical doc\` for the full command reference, or \`empirical doc memory\` for exact query/record syntax.${copilotAddendum}
 ${END_MARKER}`;
 }
 
@@ -117,7 +129,7 @@ function writeCoreMemoryGuidance(hostId, pluginNames = [CORE_PLUGIN_NAME]) {
   let filePath = null;
   try {
     filePath = instructionsFilePathForHost(hostId);
-    const block = buildCoreMemoryBlock({ pluginNames: pluginNames && pluginNames.length ? pluginNames : [CORE_PLUGIN_NAME] });
+    const block = buildCoreMemoryBlock({ pluginNames: pluginNames && pluginNames.length ? pluginNames : [CORE_PLUGIN_NAME], hostId });
     upsertCoreMemoryBlock(filePath, block);
     log(`  - Wrote Empirical core memory guidance to ${filePath}.`);
     return filePath;

package/lib/installers/hooks.js

@@ -571,8 +571,25 @@ function runMemoryQuery(args) {
   });
 }
 
+// 2026-09-18: GitHub's own hooks reference (re-checked - the August 2026 check this file used to
+// cite was stale) confirms sessionStart CAN inject additionalContext for command-type hooks, same
+// flat { additionalContext: "..." } shape postToolUse etc. use. This event's input payload also
+// carries an optional initialPrompt - using it as the query (like the removed UserPromptSubmit
+// hook did for its own prompt) makes the one real query relevant to what's actually being asked,
+// not just a generic default.
+function readStdinPayload() {
+  try {
+    var raw = fs.readFileSync(0, 'utf8');
+    return raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    return {};
+  }
+}
+
 function main() {
   appendLog('hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
+  var payload = readStdinPayload();
+  var initialPrompt = String((payload && (payload.initialPrompt || payload.initial_prompt)) || '').trim();
 
   if (!commandExists('empirical')) {
     appendLog('empirical CLI not found on PATH, exiting');
@@ -651,9 +668,9 @@ function main() {
   var topics = envTopics.length ? envTopics : fileConfig.topics;
   var contextMatch = topics.length
     ? topics.join(', ')
-    : 'project context, conventions, recent decisions, user preferences';
+    : (initialPrompt || 'project context, conventions, recent decisions, user preferences');
 
-  appendLog('project tag=' + (tag || '(none)') + ' (source=' + tagSource + '), topics=' + (topics.length ? topics.join('|') : '(default)'));
+  appendLog('project tag=' + (tag || '(none)') + ' (source=' + tagSource + '), topics=' + (topics.length ? topics.join('|') : '(default)') + ', usingInitialPrompt=' + Boolean(initialPrompt && !topics.length));
 
   // Scope every query to the project. Measured 2026-09-16: with no tag filter all 8 slots went to
   // one unrelated project during a full session in a different repo, so the only automatic context
@@ -699,9 +716,13 @@ function main() {
   });
   lines.push('- Before risky or repeated work, ask first: empirical memory query --match "<what you are about to do>" --tags scar-tissue');
 
-  // Logged only - Copilot's sessionStart event has no field that surfaces this to the model.
-  appendLog('memory query returned ' + results.length + ' result(s) (session-start has no output channel to inject them, logged only): ' + lines.join(' | '));
-  console.log('{}');
+  // additionalContext is honored for command-type sessionStart hooks (re-confirmed 2026-09-18
+  // against GitHub's current hooks reference - the prior "no output channel" comment here was
+  // stale). Delivered invisibly: this never touches the visible prompt, unlike the UserPromptSubmit
+  // approach it replaces (removed - see installCopilotHooks's comment).
+  var block = 'Empirical memory context for this session:\\n' + lines.join('\\n');
+  appendLog('memory query returned ' + results.length + ' result(s), injecting via additionalContext');
+  console.log(JSON.stringify({ additionalContext: block }));
   process.exit(0);
 }
 
@@ -714,11 +735,21 @@ try {
 }
 `;
 
+// Copilot has no UserPromptSubmit real-recall hook (removed 2026-09-18, superseded by
+// additionalContext delivery through COPILOT_HOOK_SESSION_START_SOURCE above). That approach was
+// abandoned because Copilot renders the ENTIRE modifiedPrompt back in the terminal as the user's
+// own visible message - confirmed live, not documented, and not what "real hook" was supposed to
+// mean. sessionStart's additionalContext (re-confirmed against current GitHub docs - the prior
+// "no output channel" comment on that hook was stale) delivers the same real query invisibly
+// instead, at the cost of firing once per real session rather than being keyed to the very first
+// prompt's exact text (it uses the sessionStart payload's own initialPrompt field instead, which
+// is present per GitHub's schema but not verified live as of this comment).
+
 // Codex-only variant of the Stop reminder. Confirmed live (2026-08-08, via a real `codex
 // exec` run) that Codex's Stop hook specifically requires a { systemMessage: "..." } JSON shape
 // on stdout - plain text makes Codex report the hook as failed. Distinct from Claude's own JSON
-// shape (hookSpecificOutput.additionalContext, see CLAUDE_HOOK_STOP_SOURCE below) and Copilot's
-// (decision/reason, see COPILOT_HOOK_STOP_SOURCE) - each host has its own schema here.
+// shape (hookSpecificOutput.additionalContext, see CLAUDE_HOOK_STOP_SOURCE below). Copilot has no
+// Stop hook at all (removed 2026-09-18, see the comment above CLAUDE_HOOK_STOP_SOURCE).
 const CODEX_HOOK_STOP_SOURCE = `#!/usr/bin/env node
 'use strict';
 
@@ -776,82 +807,20 @@ try {
 }
 `;
 
-// Copilot-only variant of the Stop reminder above. Per GitHub's own hooks reference (fetched
-// 2026-08-08): agentStop's output schema is { decision: "block"|"allow", reason, modifiedResponse }
-// - there is no plain message field, so surfacing a reminder means returning decision:"block"
-// with reason as the forced-continuation prompt text. Confirmed this has the same loop-prevention
-// contract Claude Code uses: the input payload includes stop_hook_active ("true when this turn
-// was already forced to continue by a prior 'block' decision" - same semantics, same field name
-// as Claude's), and Copilot has its own hard backstop besides ("After 8 consecutive block
-// continuations, the CLI overrides the hook and ends the turn anyway"). Checking stop_hook_active
-// here means this hook only ever forces one continuation, never chains into that backstop.
-const COPILOT_HOOK_STOP_SOURCE = `#!/usr/bin/env node
-'use strict';
-
-var fs = require('fs');
-var os = require('os');
-var path = require('path');
-
-var LOG_PATH = path.join(os.homedir(), '.empirical', 'hooks', 'stop.log');
-var MAX_LOG_BYTES = 200 * 1024;
-
-function appendLog(line) {
-  try {
-    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
-    fs.appendFileSync(LOG_PATH, '[' + new Date().toISOString() + '] ' + line + '\\n');
-    var stat = fs.statSync(LOG_PATH);
-    if (stat.size > MAX_LOG_BYTES) {
-      var tail = fs.readFileSync(LOG_PATH, 'utf8').slice(-MAX_LOG_BYTES / 2);
-      fs.writeFileSync(LOG_PATH, tail);
-    }
-  } catch (e) {
-    // Diagnostics must never break the hook.
-  }
-}
-
-function readStdinPayload() {
-  try {
-    var raw = fs.readFileSync(0, 'utf8');
-    return raw ? JSON.parse(raw) : {};
-  } catch (e) {
-    return {};
-  }
-}
-
-function main() {
-  var payload = readStdinPayload();
-
-  if (payload && payload.stop_hook_active === true) {
-    appendLog('stop_hook_active=true, skipping reminder (already forced one continuation this turn)');
-    console.log('{}');
-    process.exit(0);
-  }
-
-  appendLog('stop hook fired (pid=' + process.pid + ', platform=' + process.platform + '), forcing one continuation to surface reminder');
-
-  console.log(JSON.stringify({
-    decision: 'block',
-    reason: '[Empirical reminder] Before finishing: if this turn included a completed decision, a corrected mistake, or meaningful work worth remembering, record it now, one memory per finding (a fix, a root cause, a decision, a lesson), via the empirical-memory, empirical-work-history, or empirical-scar-tissue skill or \`empirical memory record\`. Local notes are not recorded. Do not wait to be asked.'
-  }));
-  process.exit(0);
-}
-
-try {
-  main();
-} catch (e) {
-  try { appendLog('uncaught error in main(): ' + (e && e.message)); } catch (_e) { /* best effort */ }
-  console.log('{}');
-  process.exit(0);
-}
-`;
+// Copilot's Stop reminder (agentStop) was removed entirely 2026-09-18 - see installCopilotHooks's
+// comment in this file for why (agentStop only supports decision:"block"|"allow" with no passive
+// field, so any reminder there forces a disruptive extra visible turn; no per-session cap on that
+// avoids the tradeoff between nagging every turn and going silent right before something worth
+// recording happens - confirmed live 2026-09-17/18 causing both failure modes in turn). Copilot
+// relies entirely on copilot-instructions.md instead (see coreMemoryBlock.js's Copilot addendum).
 
 // Claude-only variant of the Stop reminder above. hookSpecificOutput.additionalContext (stdout,
 // exit 0) is Claude Code's non-blocking Stop-hook feedback channel: the text is fed into context
 // and the conversation continues, same outcome the earlier exit-2 approach achieved, but the
 // transcript UI renders it as a plain system reminder instead of a red "Stop hook error" line.
-// Codex needs its own systemMessage shape (CODEX_HOOK_STOP_SOURCE) and Copilot its own
-// decision/reason shape (COPILOT_HOOK_STOP_SOURCE) - plain console.log output (what this hook
-// used before the additionalContext fix) never reaches the model on any of the three hosts.
+// Codex needs its own systemMessage shape (CODEX_HOOK_STOP_SOURCE) - plain console.log output
+// (what this hook used before the additionalContext fix) never reaches the model. Copilot has no
+// Stop hook at all (removed 2026-09-18, see the comment just above this one).
 const CLAUDE_HOOK_STOP_SOURCE = `#!/usr/bin/env node
 'use strict';
 
@@ -929,17 +898,19 @@ try {
 // The message itself is generated per-install from the actual plugin set being installed, not one
 // fixed string for everyone - e.g. someone who declined empirical-scar-tissue at install time
 // never sees a scar-tissue reminder, since that capability isn't actually available to them.
+//
+// Claude and Codex only - Copilot has no UserPromptSubmit reminder at all (removed 2026-09-18,
+// see installCopilotHooks's comment in this file for why: its only output field is a full prompt
+// replacement, not a side channel, so any injected reminder here reads as fake, model-authored
+// text inside what looks like the user's own message).
 function buildPromptReminderMessage(pluginNames, platform) {
   const names = normalizePluginNames(pluginNames);
+
   const lines = [
     'Before responding: if this task needs prior context (research, debugging, a spec or status update, a handoff), query Empirical memory first via the empirical-memory skill or empirical memory query - do not assume you already have enough context.'
   ];
   if (names.includes('empirical-work-history')) {
     lines.push('If you are picking up previously completed work, check for a recent work-history entry before assuming there is none.');
-    // Codex Stop runs after its final response has already been emitted, so it can only be an
-    // advisory reminder. Put the completion gate into the pre-response context instead, where
-    // Codex can still act on it. Keep this Codex-specific: Claude and Copilot have their own
-    // stop-hook control flows and should not receive a changed prompt contract here.
     if (platform === 'codex') {
       lines.push('If this turn results in meaningful completed work, BEFORE sending your final response you MUST use the empirical-work-history skill or record it via Empirical. The entry must carry tag work-history and mass 1; verify the create receipt. CLI fallback must use --json-file with data.session and data.git; do not use the shorthand record command for coding work. Do not wait for the Stop hook.');
     }
@@ -960,52 +931,19 @@ function buildPromptReminderMessage(pluginNames, platform) {
 // `platform`:
 //  - 'codex': Codex's required hookSpecificOutput.additionalContext JSON shape (confirmed live
 //    2026-08-08 via a real `codex exec` run - plain text made Codex report the hook as failed).
-//  - 'copilot': Copilot's userPromptSubmitted event has NO additionalContext-equivalent field at
-//    all (confirmed via GitHub's own hooks reference, fetched 2026-08-08) - the only output field
-//    is modifiedPrompt, which REPLACES the prompt for the rest of the turn. So this reads the
-//    real prompt text from stdin's `prompt` field and returns it with the reminder appended -
-//    more invasive than Claude/Codex's side-channel injection (it's now part of the visible
-//    prompt), but it's the only mechanism this event actually has. Falls back to {} (leave
-//    unchanged) if stdin can't be read/parsed or has no prompt field, so a parsing edge case can
-//    never corrupt or blank out the user's actual prompt.
-//  - default (Claude/Copilot's plain console.log was the old assumption for both - WRONG for
-//    Copilot, which requires valid JSON on stdout for every event, confirmed via the same fetch
-//    above): plain console.log, confirmed correct for Claude only.
+//  - default ('claude'): plain console.log.
+// Copilot has no variant here at all (removed 2026-09-18) - see installCopilotHooks's comment.
 function buildUserPromptSubmitHookSource(pluginNames, platform) {
   const messageLiteral = JSON.stringify(buildPromptReminderMessage(pluginNames, platform));
 
-  let stdinHelper = '';
-  let outputStatement;
-  if (platform === 'codex') {
-    outputStatement = `console.log(JSON.stringify({
+  const outputStatement = platform === 'codex'
+    ? `console.log(JSON.stringify({
     hookSpecificOutput: {
       hookEventName: 'UserPromptSubmit',
       additionalContext: ${messageLiteral}
     }
-  }));`;
-  } else if (platform === 'copilot') {
-    stdinHelper = `
-function readStdinPayload() {
-  try {
-    var raw = fs.readFileSync(0, 'utf8');
-    return raw ? JSON.parse(raw) : {};
-  } catch (e) {
-    return {};
-  }
-}
-`;
-    outputStatement = `var payload = readStdinPayload();
-  if (payload && typeof payload.prompt === 'string' && payload.prompt.length > 0) {
-    console.log(JSON.stringify({
-      modifiedPrompt: payload.prompt + '\\n\\n' + ${messageLiteral}
-    }));
-  } else {
-    appendLog('no usable prompt field on stdin payload, leaving prompt unchanged');
-    console.log('{}');
-  }`;
-  } else {
-    outputStatement = `console.log(${messageLiteral});`;
-  }
+  }));`
+    : `console.log(${messageLiteral});`;
 
   return `#!/usr/bin/env node
 'use strict';
@@ -1030,7 +968,7 @@ function appendLog(line) {
     // Diagnostics must never break the hook.
   }
 }
-${stdinHelper}
+
 // A crash here must degrade to a silent no-op, never a visible "hook failed" error in the host CLI.
 try {
   appendLog('user-prompt-submit hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
@@ -1268,19 +1206,45 @@ function installCodexHooks(pluginNames) {
 // GitHub Copilot CLI's hook config is one JSON file per hook under ~/.copilot/hooks/ (any
 // filename — confirmed via GitHub's own docs at docs.github.com/en/copilot/reference/hooks-
 // reference), so unlike Claude/Codex this never needs to merge into a shared file: Empirical
-// owns this file outright and can just overwrite it. Event key for turn-end is "agentStop"
-// ("the main agent finishes a turn" per the same docs) — not "stop"/"Stop" like Claude/Codex.
-// Schema: { version: 1, hooks: { sessionStart: [...], agentStop: [...] } }.
-function installCopilotHooks(pluginNames) {
+// owns this file outright and can just overwrite it.
+//
+// SessionStart only (2026-09-18): userPromptSubmitted and agentStop reminder hooks were removed
+// for Copilot entirely, not just capped. Both were fundamentally fake compared to Claude/Codex's
+// versions: userPromptSubmitted's only output field is modifiedPrompt (a full prompt replacement,
+// not a side-channel), so its "reminder" was really text injected into what looks like the user's
+// own message; agentStop only supports decision:"block"|"allow" with no passive/silent field, so
+// any reminder there forces a disruptive extra visible turn, and no per-session cap on that can
+// avoid the tradeoff between nagging every turn and going silent right before something worth
+// recording happens (confirmed live 2026-09-17/18: both caused real, reproducible bugs - a
+// prompt-blanking regression and an unstoppable "record your work" loop). Copilot instead relies
+// entirely on the identity-framed instructions block coreMemoryBlock.js writes into
+// copilot-instructions.md, same mechanism Claude/Codex have as a backstop under their working
+// hooks - see that file's Copilot-only addendum for the stronger, more directive wording this
+// puts on Copilot specifically to compensate for having no hook nudge at all.
+function installCopilotHooks(_pluginNames) {
   const hooksDir = getEmpiricalHooksDir();
   ensureDir(hooksDir);
 
   const sessionStartScriptPath = path.join(hooksDir, 'copilot-session-start.js');
-  const stopScriptPath = path.join(hooksDir, 'copilot-stop.js');
-  const userPromptScriptPath = path.join(hooksDir, 'copilot-user-prompt-submit.js');
   writeFile(sessionStartScriptPath, COPILOT_HOOK_SESSION_START_SOURCE);
-  writeFile(stopScriptPath, COPILOT_HOOK_STOP_SOURCE);
-  writeFile(userPromptScriptPath, buildUserPromptSubmitHookSource(pluginNames, 'copilot'));
+
+  // Clean up scripts/state files from every removed Copilot hook (agentStop's Stop reminder, the
+  // visible-modifiedPrompt UserPromptSubmit real-recall hook it was briefly replaced with) so an
+  // upgrade never leaves orphaned, unregistered files behind.
+  const fs = require('fs');
+  const staleFiles = [
+    path.join(hooksDir, 'copilot-stop.js'),
+    path.join(hooksDir, 'stop-state.json'),
+    path.join(hooksDir, 'copilot-user-prompt-submit.js'),
+    path.join(hooksDir, 'prompt-state.json')
+  ];
+  for (const stalePath of staleFiles) {
+    try {
+      if (fs.existsSync(stalePath)) fs.unlinkSync(stalePath);
+    } catch (_error) {
+      // best-effort cleanup only
+    }
+  }
 
   const copilotHooksDir = path.join(os.homedir(), '.copilot', 'hooks');
   ensureDir(copilotHooksDir);
@@ -1290,7 +1254,6 @@ function installCopilotHooks(pluginNames) {
   // never lingers alongside the new one.
   const legacyHookFilePath = path.join(copilotHooksDir, 'empirical-session-start.json');
   try {
-    const fs = require('fs');
     if (fs.existsSync(legacyHookFilePath)) fs.unlinkSync(legacyHookFilePath);
   } catch (_error) {
     // best-effort cleanup only
@@ -1301,6 +1264,13 @@ function installCopilotHooks(pluginNames) {
   // PowerShell requires - see buildPowershellHookCommand) are always set: per GitHub's hooks
   // reference, an explicit `powershell` entry takes precedence over `command` on Windows, so this
   // is correct on both platforms without needing to detect the install-time OS here.
+  //
+  // sessionStart only (2026-09-18): no agentStop (recording stays instructions-only, see
+  // coreMemoryBlock.js's Copilot addendum) and no userPromptSubmitted (its only output field,
+  // modifiedPrompt, is rendered back as the user's own visible message - confirmed live, not
+  // acceptable for silent recall). sessionStart's additionalContext delivers the same real query
+  // invisibly instead, once per real session boundary (not an artificial timer), using that
+  // event's own initialPrompt field as the query when present.
   const hookFileContent = {
     version: 1,
     hooks: {
@@ -1311,30 +1281,12 @@ function installCopilotHooks(pluginNames) {
           powershell: buildPowershellHookCommand(sessionStartScriptPath),
           timeoutSec: 15
         }
-      ],
-      // "userPromptSubmitted" per GitHub's hooks reference ("The user submits a prompt") - not
-      // "userPromptSubmit" (that camelCase spelling is Claude/Codex's convention, not Copilot's).
-      userPromptSubmitted: [
-        {
-          type: 'command',
-          command: buildHookCommand(userPromptScriptPath),
-          powershell: buildPowershellHookCommand(userPromptScriptPath),
-          timeoutSec: 10
-        }
-      ],
-      agentStop: [
-        {
-          type: 'command',
-          command: buildHookCommand(stopScriptPath),
-          powershell: buildPowershellHookCommand(stopScriptPath),
-          timeoutSec: 10
-        }
       ]
     }
   };
 
   writeFile(hookFilePath, `${JSON.stringify(hookFileContent, null, 2)}\n`);
-  log('  - Copilot SessionStart + userPromptSubmitted + agentStop hooks installed for deterministic memory lookups and reminders.');
+  log('  - Copilot SessionStart hook installed (real recall via additionalContext). No UserPromptSubmit/agentStop reminders - see copilot-instructions.md instead.');
 }
 
 module.exports = {
@@ -1342,7 +1294,6 @@ module.exports = {
   CODEX_HOOK_SESSION_START_SOURCE,
   COPILOT_HOOK_SESSION_START_SOURCE,
   CODEX_HOOK_STOP_SOURCE,
-  COPILOT_HOOK_STOP_SOURCE,
   CLAUDE_HOOK_STOP_SOURCE,
   buildPromptReminderMessage,
   buildUserPromptSubmitHookSource,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empirical-gauzza/cli",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "Persistent cross-tool memory for AI agents. Give Claude Code, Codex, Copilot, Cursor, and ChatGPT one shared memory: save project context once, recall it everywhere via CLI or MCP.",
   "keywords": [
     "memory",