Keep sessionStart hook additionalContext after compaction #5225

Activity

1. github-actions

   added

   triage

   on Oct 22, 2026
2. copilot-cli-bot

   added

   area:context-memoryContext window, memory, compaction, checkpoints, and instruction loadingContext window, memory, compaction, checkpoints, and instruction loading

   area:pluginsPlugin system, marketplace, hooks, skills, extensions, and custom agentsPlugin system, marketplace, hooks, skills, extensions, and custom agents

   and removed

   triage

   on Oct 22, 2026
3. copilot-cli-bot

   added the

   Feature

   issue type on Oct 22, 2026
4. John-Rood commented on Oct 23, 2026

   

   John-Rood

   on Oct 23, 2026

   More actions

   Separate two questions here: why the context is gone, and which of your three options the runtime can actually ship.

   Why it is gone. The runtime delivers sessionStart additionalContext as its own user message directly after the system message, which your first post-compaction request shows plainly. Compaction then rebuilds the message list from the summary plus a token-bounded tail, and that message is neither system content nor something the summarizer has to preserve. It drops by construction. So option 1 is not just "keep the message": it needs a rule for which messages are exempt from the tail budget, and you would still be racing the summarizer folding the text into the summary.

   Option 2 is the smallest change. The resume path already runs sessionStart and already injects its output as that same message, so a compact source reuses an existing injection path with one more enum value on the compaction branch. The data is at the call site: preCompact already receives trigger ("manual" or "auto") and transcriptPath, so the handler that decides a compaction is happening is the same one that could raise the second event.

   Option 3 is the largest. In 1.0.103 preCompact is wired notification-only and there is no post-compaction event at all, so additionalContext from a postCompact hook is a new delivery path rather than a new field.

   Until option 2 lands, the only content that survives compaction is what sits inside the system message, which your table already proves for copilot-instructions.md. That gives a workaround that does not ask users to edit a personal file: the plugin owns a managed block in that file and rewrites it from its own source, so the copy cannot go stale.

   Three hooks, one file. In $COPILOT_HOME/hooks/rules-digest.json (default ~/.copilot/hooks/):

   {
     "version": 1,
     "hooks": {
       "sessionStart": [
         { "type": "command", "command": "node /path/to/rules-digest.mjs sessionStart", "env": { "RULES_SRC": "/path/to/plugin/rules" } }
       ],
       "preCompact": [
         { "type": "command", "command": "node /path/to/rules-digest.mjs preCompact", "env": { "RULES_SRC": "/path/to/plugin/rules" } }
       ],
       "postToolUse": [
         { "type": "command", "command": "node /path/to/rules-digest.mjs postToolUse", "env": { "RULES_SRC": "/path/to/plugin/rules" } }
       ]
     }
   }

   rules-digest.mjs:

   #!/usr/bin/env node
   // rules-digest.mjs: keep plugin rules in the system message, re-inject once after compaction.
   import fs from 'node:fs';
   import os from 'node:os';
   import path from 'node:path';
   
   const mode = process.argv[2];
   const home = process.env.COPILOT_HOME || path.join(os.homedir(), '.copilot');
   const target = path.join(home, 'copilot-instructions.md');
   const BEGIN = '<!-- rules-digest:begin -->';
   const END = '<!-- rules-digest:end -->';
   const max = Number(process.env.RULES_MAX || 6000);
   
   let input = {};
   try { input = JSON.parse(fs.readFileSync(0, 'utf8') || '{}'); } catch {}
   
   function digest() {
     const src = process.env.RULES_SRC || '';
     let text = '';
     try {
       text = fs.statSync(src).isDirectory()
         ? fs.readdirSync(src).filter(f => f.endsWith('.md')).sort()
             .map(f => fs.readFileSync(path.join(src, f), 'utf8')).join('\n\n')
         : fs.readFileSync(src, 'utf8');
     } catch { return ''; }
     text = text.trim();
     const bytes = Buffer.from(text);
     if (bytes.length <= max) return text;
     return bytes.subarray(0, max).toString('utf8').replace(/\n[^\n]*$/, '') +
       `\n\n[digest truncated at ${max} bytes]`;
   }
   
   function sync() {
     const d = digest();
     if (!d) return;
     let cur = '';
     try { cur = fs.readFileSync(target, 'utf8'); } catch {}
     const start = cur.indexOf(BEGIN), stop = cur.indexOf(END);
     const head = start >= 0 ? cur.slice(0, start) : (cur ? cur.trimEnd() + '\n\n' : '');
     const tail = stop > start ? cur.slice(stop + END.length) : '\n';
     const next = `${head}${BEGIN}\n${d}\n${END}${tail}`;
     if (next === cur) return;
     fs.mkdirSync(path.dirname(target), { recursive: true });
     fs.writeFileSync(target + '.tmp', next);
     fs.renameSync(target + '.tmp', target);
   }
   
   const flagPath = path.join(home, 'hooks-state',
     String(input.sessionId || 'session').replace(/[^\w.-]/g, '_') + '.compact');
   
   if (mode === 'sessionStart') {
     sync();
     process.stdout.write('{}');
   } else if (mode === 'preCompact') {
     sync();
     const d = digest();
     if (d) {
       fs.mkdirSync(path.dirname(flagPath), { recursive: true });
       fs.writeFileSync(flagPath, JSON.stringify({ digest: d, trigger: input.trigger || null }));
     }
     process.stdout.write('{}');
   } else if (mode === 'postToolUse') {
     let pending = null;
     try { pending = JSON.parse(fs.readFileSync(flagPath, 'utf8')); } catch {}
     if (!pending) process.stdout.write('{}');
     else {
       fs.rmSync(flagPath, { force: true });
       process.stdout.write(JSON.stringify({
         additionalContext: 'Your session rules were replaced by the last compaction. '
           + 'They are reproduced here once so they hold for the rest of the session.\n\n' + pending.digest,
       }));
     }
   } else {
     process.stderr.write('usage: rules-digest.mjs sessionStart|preCompact|postToolUse\n');
     process.exit(2);
   }

   What each one buys you:

   • sessionStart writes the block, so a session that later compacts starts with the rules in the system message. No output to the model, no duplicate.
   • preCompact writes it again, for the next session. The system message for the running session is already built, so this one is preparation, not rescue.
   • postToolUse covers the cases the block cannot: the system message being rebuilt on a model switch, or the block being stale when the session started. preCompact leaves a per-session flag, and the first tool call after the compaction appends the current digest to that tool result and clears the flag. One injection per compaction, not one per turn, so history does not grow.

   Tested here against mock payloads, not against a live session: the managed block is written with the user's own text outside the markers preserved, a second run is a no-op, a digest over budget truncates at a line boundary, the flag is per sessionId and consumed by exactly one postToolUse, and a missing RULES_SRC or malformed stdin returns {} with exit 0 so the hook cannot break a session. The claim that the instructions file survives compaction is your measurement, not a second one from me.

   Two limits worth writing down. postToolUse additionalContext is appended to the tool result and capped at 10 KB, which is why the budget defaults to 6000 bytes. And a plugin writing into copilot-instructions.md needs the markers, or it will eventually eat a user's hand-written file.

   If the behavior stays as it is, the docs note you asked for is the minimum. The hooks reference already says preCompact output is not processed, so the sessionStart row is the one missing a caveat about compaction.

   The other half of this is the history the rules are applied to. After a compaction the summary keeps the shape of the work, not the specifics, and a new session starts with none of it. MemoryRouter keeps the conversation itself across sessions and survives compaction, and it runs as an MCP server, so the CLI can load it next to your existing servers: https://docs.memoryrouter.ai/mcp?utm_source=github&utm_medium=issue&utm_campaign=github-copilot-cli