@wjarka/cezarion 0.16.0 → 0.17.0

package/scripts/mock-runner-crash.mjs

@@ -15,10 +15,26 @@ export function crashWithStderr(prompt, malformedFrame) {
     process.exit(7);
   }
   if (prompt.includes('mock:crash-stderr-held-pipe')) {
-    spawn(process.execPath, ['-e', `setTimeout(() => process.stderr.write('late buffered crash diagnostic\\n'), 40); setTimeout(() => {}, 5000);`], {
-      stdio: ['ignore', process.stdout, process.stderr],
+    // Start the drain deadline only after the descendant is ready. Otherwise
+    // cold Node startup competes with the runner's bounded post-exit drain.
+    // The late line comes 250ms after the leader's exit, late enough that a
+    // runner that stops draining reliably fails S19 (hearsay-tools/cezarion#887).
+    const child = spawn(process.execPath, ['-e', `
+      process.on('disconnect', () => {
+        setTimeout(() => process.stderr.write('late buffered crash diagnostic\\n'), 250);
+        setTimeout(() => {}, 5000);
+      });
+      process.send('ready');
+    `], {
+      stdio: ['ignore', process.stdout, process.stderr, 'ipc'],
     });
+    child.once('message', () => emitCrash(malformedFrame));
+    return true;
   }
+  emitCrash(malformedFrame);
+}
+
+function emitCrash(malformedFrame) {
   writeSync(2, 'Error: transient connection reset; retrying\nRecovered\n');
   if (malformedFrame) writeSync(1, malformedFrame + '\n');
   writeSync(2, `node:events:496

package/scripts/mock-session-context.d.mts

@@ -0,0 +1,5 @@
+export function withoutSessionContext<T>(text: T): T;
+export function withoutSessionContextBody(body: string): string;
+export function withoutSessionContextParts<T>(parts: T): T;
+export function stripCommandMessage<T extends object>(command: T): T;
+export function rawMessage(command: { message?: unknown }): unknown;

package/scripts/mock-session-context.mjs

@@ -0,0 +1,56 @@
+// hearsay-tools/cezarion#1584: an opening message starts with <cezar-context> blocks, and the
+// handoff block repeats the task's Goal. A mock picks its scenario from `mock:` tokens anywhere
+// in the text, so without this a Continue would replay the first task's scenario. Mocks record
+// the raw native text, then match scenarios on the text without the blocks.
+const BLOCK = /^<cezar-context id="[^"]*"(?: source="[^"]*")?>\n[\s\S]*?\n<\/cezar-context>(?:\n\n)?/;
+const SEPARATOR = '---\n\n';
+
+/** `text` without its leading session-context blocks and their separator; unchanged otherwise. */
+export function withoutSessionContext(text) {
+  if (typeof text !== 'string') return text;
+  // In-thread runners put their system instructions first, divided by the same separator.
+  const start = text.indexOf('<cezar-context id="');
+  if (start < 0 || (start > 0 && !text.slice(0, start).endsWith('\n\n---\n\n'))) return text;
+  let rest = text.slice(start);
+  let stripped = false;
+  for (let match = BLOCK.exec(rest); match; match = BLOCK.exec(rest)) {
+    rest = rest.slice(match[0].length);
+    stripped = true;
+  }
+  if (!stripped || !rest.startsWith(SEPARATOR)) return text;
+  return text.slice(0, start) + rest.slice(SEPARATOR.length);
+}
+
+/** The same for an OpenCode request body: each part's text, the JSON otherwise unchanged. */
+export function withoutSessionContextBody(body) {
+  // A JSON body escapes the attribute's quote, so look for the tag name alone.
+  if (!body || !body.includes('<cezar-context id=')) return body;
+  try {
+    const parsed = JSON.parse(body);
+    if (!Array.isArray(parsed.parts)) return body;
+    return JSON.stringify({ ...parsed, parts: parsed.parts.map((part) => typeof part?.text === 'string' ? { ...part, text: withoutSessionContext(part.text) } : part) });
+  } catch {
+    return body;
+  }
+}
+
+/** The same for a list of native input parts (Codex `input`, ACP `prompt`). */
+export function withoutSessionContextParts(parts) {
+  return Array.isArray(parts)
+    ? parts.map((part) => typeof part?.text === 'string' ? { ...part, text: withoutSessionContext(part.text) } : part)
+    : parts;
+}
+
+const RAW = new WeakMap();
+/** Pi/OMP RPC: strip `command.message` for matching and keep the raw text for the recording. */
+export function stripCommandMessage(command) {
+  if (command && typeof command.message === 'string') {
+    RAW.set(command, command.message);
+    command.message = withoutSessionContext(command.message);
+  }
+  return command;
+}
+/** The native text a Pi/OMP command arrived with, for the recording. */
+export function rawMessage(command) {
+  return RAW.has(command) ? RAW.get(command) : command.message;
+}

package/scripts/mock-silent-tail.mjs

@@ -9,12 +9,13 @@ export const SILENT_TAIL_DONE = 'Filed #543.\nCEZ:DONE';
 export const TOOL_TAIL_OPENING = 'Inspecting the working tree.';
 export const FINAL_MESSAGE_STANDING = 'Here is where things stand.';
 export const SLOW_DONE_PREFIX = 'Working on the wrap-up.';
-export const FINAL_MESSAGE_NUDGE_PREFIX = 'Your last turn ended without a message to the user.';
-/** Bound in F9/F11 is 300 ms; reply after expiry. */
+// Cezar's no-wait nudge absorbed the final-message nudge (hearsay-tools/cezarion#1234).
+export const FINAL_MESSAGE_NUDGE_PREFIX = 'Your turn ended without a wait or done.';
+/** F9/F11 gate replies on CEZ_MOCK_RELEASE_FILE; ungated callers use this delay. */
 export const LATE_REPLY_MS = 500;
 /** Bound in F10 is 300 ms; first content is immediate, turn-end after this. */
 export const SLOW_DONE_TAIL_MS = 400;
-/** F11: after native turn-start, hold before content longer than the test poll window. */
+/** F11 gates content on `${CEZ_MOCK_RELEASE_FILE}.content`; ungated callers use this delay. */
 export const LATE_TURN_START_HOLD_MS = 800;
 
 export function sleep(ms) {
@@ -32,6 +33,12 @@ export function noteSilentTailPrompt(prompt) {
   else if (prompt.includes('mock:silent-tail-slow-done')) opened = 'silent-tail-slow-done';
   else if (prompt.includes('mock:silent-tail-again')) opened = 'silent-tail-again';
   else if (prompt.includes('mock:silent-tail')) opened = 'silent-tail';
+  else if (prompt.includes('mock:tool-tail')) opened = 'tool-tail';
+}
+
+/** The session opened one of these scenarios, so they answer its nudge. */
+export function silentTailOpened() {
+  return opened !== undefined;
 }
 
 export function isSilentTailScenario(prompt) {

package/scripts/pi-default-tools.mjs

@@ -0,0 +1,22 @@
+// hearsay-tools/cezarion#1305: pi reads --tools as an allowlist, so a session given cezar's default
+// tool list could not call an MCP server's tools (direct, codemode or deferred) or any tool another
+// pi extension registers. For the default list cezar sends --no-builtin-tools instead, which keeps
+// every tool registered, activates extension tools on registration and leaves the built-ins
+// inactive, and names the built-ins in --cezar-builtin-tools for this extension to activate.
+//
+// Written against pi 1.0.4. The names are added to the active tools on every session_start
+// (startup, resume, new, reload), never removed: pi's MCP extension activates codemode and
+// tool_search itself, before or after this handler runs. pi ignores unknown and hidden names, and an
+// --exclude-tools name is never registered, so naming one here cannot bring it back.
+const FLAG = 'cezar-builtin-tools';
+
+export default function registerPiDefaultTools(pi) {
+  pi.registerFlag(FLAG, { type: 'string', description: 'Built-in tools cezar activates (default tool list)' });
+  pi.on('session_start', () => {
+    const value = pi.getFlag(FLAG);
+    if (typeof value !== 'string') return;
+    const names = value.split(',').map((name) => name.trim()).filter(Boolean);
+    if (names.length === 0) return;
+    pi.setActiveTools([...new Set([...pi.getActiveTools(), ...names])]);
+  });
+}

package/scripts/pi-project-skills.mjs

@@ -0,0 +1,59 @@
+// hearsay-tools/cezarion#1295: pi loads a project's .pi/skills and .agents/skills only once the
+// user trusts the folder, and an RPC session with no saved decision silently gets neither. Offer
+// the same folders through resources_discover for an untrusted folder only: a trusted one already
+// loads them under its own settings filters. Extensions, MCP servers and the trust decision itself
+// stay untouched.
+//
+// The skill list matches a trusted session's for the portable <name>/SKILL.md layout only, and
+// two differences remain (pi 1.0.4). pi scans a skillPaths folder in its "pi" mode, not the
+// "agents" mode of its trusted .agents/skills scan, so a loose .md file directly in .agents/skills
+// loads here and a loose .md in one of its subfolders does not. And pi appends these paths after
+// the user's own skills, so on a name collision the user's copy wins where a trusted session
+// keeps the project's. An extension cannot change either.
+import { existsSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+// pi's CONFIG_DIR_NAME (package.json piConfig.configDir) and getHomeDir(), as of pi 1.0.4.
+const CONFIG_DIR_NAME = '.pi';
+const homeDir = () => process.env.HOME || homedir();
+
+export default function registerPiProjectSkills(pi) {
+  pi.on('resources_discover', (event, ctx) => {
+    // A pi without isProjectTrusted has no trust gate, so it already loads the project's skills.
+    if (typeof ctx?.isProjectTrusted !== 'function' || ctx.isProjectTrusted()) return;
+    const cwd = resolve(event.cwd);
+    const userAgentsSkills = resolve(homeDir(), '.agents', 'skills');
+    const candidates = [
+      join(cwd, CONFIG_DIR_NAME, 'skills'),
+      ...ancestorAgentsSkillDirs(cwd).filter((dir) => resolve(dir) !== userAgentsSkills),
+    ];
+    return { skillPaths: candidates.filter(isDirectory) };
+  });
+}
+
+// pi's collectAncestorAgentsSkillDirs: cwd up to the first ancestor holding .git (a directory, or
+// a linked worktree's file), or the filesystem root when there is none.
+function ancestorAgentsSkillDirs(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  const dirs = [];
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    dirs.push(join(dir, '.agents', 'skills'));
+    if (dir === gitRoot || dirname(dir) === dir) return dirs;
+  }
+}
+
+function findGitRoot(start) {
+  for (let dir = start; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    if (dirname(dir) === dir) return null;
+  }
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}