@yeison.restrepo.r/code-conductor 1.23.1 → 1.23.3

package/scripts/resume-read.mjs

@@ -0,0 +1,160 @@
+// scripts/resume-read.mjs
+// ARCH-008-B: phase-entry resume reader. Zero-dep. Node-14 syntax only.
+// Exit 0 = hit (RESUME_HIT block on stdout), 3 = clean miss (zero bytes), 4 = corrupt handoff halt.
+import { existsSync, readFileSync, writeFileSync, appendFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, basename, join } from 'node:path';
+
+const SENTINEL = '0000000';
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+
+let rootTier = 1; // 1 = git toplevel, 2 = .git upward walk, 3 = script-parent
+function resolveRoot() {
+  try {
+    const top = execFileSync('git', ['rev-parse', '--show-toplevel'],
+      { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], env: process.env }).trim();
+    if (top) { rootTier = 1; return top; }
+  } catch {}
+  let dir = process.cwd();
+  for (let i = 0; i < 40; i++) {
+    if (existsSync(join(dir, '.git'))) { rootTier = 2; return dir; }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  rootTier = 3;
+  // this script lives at <root>/scripts/resume-read.mjs (dev checkout) or
+  // <root>/.claude/scripts/resume-read.mjs (deployed project).
+  const parent = join(SCRIPT_DIR, '..');
+  return basename(parent) === '.claude' ? join(parent, '..') : parent;
+}
+
+const root = resolveRoot();
+const COND = join(root, '.conductor');
+const LOG = join(COND, 'last-write.log');
+const HANDOFF = join(root, '.claude/memory/session-snapshot.json');
+const LEGACY_MD = join(root, '.claude/memory/session-snapshot.md');
+const VALIDATE = join(SCRIPT_DIR, 'snap-validate.mjs');
+const CONDUCTOR_DB = join(SCRIPT_DIR, 'conductor-db.mjs');
+
+function trace(token) {
+  try {
+    mkdirSync(COND, { recursive: true });
+    appendFileSync(LOG, new Date().toISOString() + ' resume: ' + token + '\n', { encoding: 'utf8', flag: 'a' });
+  } catch {}
+}
+
+function tryUnlink(p) { try { unlinkSync(p); } catch {} }
+function parseJson(s) { try { return JSON.parse(s); } catch { return undefined; } }
+
+function resolveHash() {
+  try {
+    const out = execFileSync('git', ['rev-parse', 'HEAD'],
+      { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], env: process.env }).trim().toLowerCase();
+    if (/^[0-9a-f]{7,64}$/.test(out)) return out;
+  } catch {}
+  return SENTINEL;
+}
+
+// Validate an existing file path via snap-validate (exit-code verdict).
+function validateFile(p) {
+  const r = spawnSync(process.execPath, [VALIDATE, p], { encoding: 'utf8', env: process.env });
+  return r.status === 0;
+}
+
+// Probe how to launch node:sqlite. Returns [] (no flag), ['--experimental-sqlite','--no-warnings'], or null (unavailable).
+function probeSqliteFlags() {
+  const opts = { encoding: 'utf8', timeout: 2000, env: process.env };
+  if (spawnSync(process.execPath, ['--no-warnings', '-e', "require('node:sqlite')"], opts).status === 0) return [];
+  if (spawnSync(process.execPath, ['--experimental-sqlite', '--no-warnings', '-e', "require('node:sqlite')"], opts).status === 0) {
+    return ['--experimental-sqlite', '--no-warnings'];
+  }
+  return null;
+}
+
+// Validate an in-memory blob by bridging it through the path-only snap-validate via a pid-unique temp.
+function validateBlob(blob) {
+  const tmp = join(COND, 'resume-validate.' + process.pid + '.tmp.json');
+  try { mkdirSync(COND, { recursive: true }); writeFileSync(tmp, blob, 'utf8'); }
+  catch { return false; } // FS write error → blob unusable, degrade
+  try {
+    const r = spawnSync(process.execPath, [VALIDATE, tmp], { encoding: 'utf8', env: process.env });
+    return r.status === 0;
+  } finally { tryUnlink(tmp); }
+}
+
+// DB branch - returns a validated snap object on a hit, or null to fall through to the file branch.
+function queryDb(hash) {
+  if (!/^([0-9a-f]{40}|[0-9a-f]{64})$/.test(hash)) {
+    trace(hash === SENTINEL ? 'sentinel-bypass' : 'nonfull-hash-bypass');
+    return null;
+  }
+  const flags = probeSqliteFlags();
+  if (flags === null) return null; // Node <22.5 or node:sqlite absent → degrade
+  const args = flags.concat([CONDUCTOR_DB, 'get-snapshot', hash]);
+  const r = spawnSync(process.execPath, args, { encoding: 'utf8', timeout: 5000, env: process.env });
+  if (r.status !== 0 || !r.stdout) return null; // timeout/kill/non-zero/empty → miss
+  const blob = r.stdout.trim();
+  if (blob === '') return null;
+  if (!validateBlob(blob)) { trace('db-invalid degrade'); return null; }
+  const snap = parseJson(blob);
+  if (snap === undefined) { trace('db-invalid degrade'); return null; }
+  return snap;
+}
+
+function buildHit(source, snap, hash) {
+  const proseAvail = typeof snap.pr === 'string' && snap.pr.length > 0;
+  const lines = [
+    'RESUME_HIT',
+    'source: ' + source,
+    'commit: ' + hash,
+    'phase: ' + snap.sys.ph,
+    'spec: ' + snap.sys.s,
+    'version: ' + snap.v,
+    'prose: ' + (proseAvail ? 'available' : 'none'),
+    'pending:'
+  ];
+  const pend = (snap.ops && Array.isArray(snap.ops.n)) ? snap.ops.n : [];
+  for (const item of pend) lines.push('- ' + item);
+  return lines.join('\n') + '\n';
+}
+
+function main() {
+  // Tier-2/tier-3 root fallbacks are diagnostically traced (git was absent or not a repo).
+  if (rootTier === 2) trace('root-tier2-gitwalk');
+  else if (rootTier === 3) trace('root-tier3-scriptparent');
+  // Legacy .md sweep - unread, best-effort.
+  if (existsSync(LEGACY_MD)) { tryUnlink(LEGACY_MD); trace('legacy-md-swept'); }
+
+  const hash = resolveHash();
+
+  // DB branch (authoritative when present + valid).
+  const dbSnap = queryDb(hash);
+  if (dbSnap) {
+    if (existsSync(HANDOFF)) tryUnlink(HANDOFF); // superseded
+    trace('db-hit @' + hash);
+    return { code: 0, out: buildHit('db', dbSnap, hash) };
+  }
+
+  // Handoff-file branch.
+  if (!existsSync(HANDOFF)) { trace('miss'); return { code: 3, out: '' }; }
+  let content;
+  try { content = readFileSync(HANDOFF, 'utf8'); }
+  catch { trace('file-unreadable degrade'); return { code: 3, out: '' }; } // leave file on disk
+  if (content.trim() === '') { trace('file-empty degrade'); tryUnlink(HANDOFF); return { code: 3, out: '' }; }
+  if (!validateFile(HANDOFF)) { trace('file-invalid halt'); return { code: 4, out: '' }; } // leave on disk
+  const snap = parseJson(content);
+  if (snap === undefined) { trace('file-invalid halt'); return { code: 4, out: '' }; }
+  if (snap.sys.c !== hash) { trace('file-stale-hash degrade'); tryUnlink(HANDOFF); return { code: 3, out: '' }; }
+  // valid + hash matches → bind (content already captured), then unlink.
+  const out = buildHit('file', snap, hash);
+  trace('file-bind+unlink');
+  tryUnlink(HANDOFF);
+  return { code: 0, out: out };
+}
+
+let res;
+try { res = main(); } catch { res = { code: 3, out: '' }; }
+if (res.out) { process.stdout.write(res.out, () => process.exit(res.code)); }
+else { process.exit(res.code); }

package/scripts/session-id.mjs

@@ -0,0 +1,67 @@
+import { readFileSync, writeFileSync, renameSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { dirname, basename, join } from 'node:path';
+
+// Repo root: git toplevel, else bounded .git upward walk, else this script's parent.
+function resolveRoot() {
+  try {
+    const top = execFileSync('git', ['rev-parse', '--show-toplevel'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (top) return top;
+  } catch { /* fall through */ }
+  let dir = process.cwd();
+  for (let i = 0; i < 40; i++) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // this script lives at <root>/scripts/session-id.mjs (dev checkout) or
+  // <root>/.claude/scripts/session-id.mjs (deployed project).
+  const parent = join(dirname(fileURLToPath(import.meta.url)), '..');
+  return basename(parent) === '.claude' ? join(parent, '..') : parent;
+}
+
+function emit(id) { process.stdout.write(id + '\n'); }
+
+// A cache value is adoptable only if it is a single non-empty token with no interior
+// whitespace/control chars and a sane length. Atomic temp+rename already prevents torn
+// writes, so this is defense-in-depth against ever emitting a truncated/garbage id.
+const looksValid = (v) => !!v && v.length <= 200 && !/\s/.test(v);
+
+function main() {
+  // Empty or whitespace-only env var is treated as unset: trim → '' → falsy → fall through.
+  const env = (process.env.CLAUDE_CODE_SESSION_ID || '').trim();
+  if (env) return emit(env);                       // primary path: cacheless, unique per session
+
+  const dir = join(resolveRoot(), '.conductor');
+  const cache = join(dir, 'session-id');
+
+  try {
+    const cached = readFileSync(cache, 'utf8').trim();
+    if (looksValid(cached)) return emit(cached);
+  } catch { /* absent or unreadable -> generate */ }
+
+  const id = randomUUID();
+  const tmp = join(dir, `session-id.${process.pid}.tmp`);
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmp, id + '\n');
+    renameSync(tmp, cache);                         // atomic publish
+  } catch {
+    // Any write-side failure is caught here: a read-only/permission-denied shared
+    // dir (EACCES/EPERM on mkdir or write), or a rename race (EEXIST on POSIX,
+    // EPERM/EACCES from a Windows AV/reader lock on the target). Re-read and adopt
+    // the winner if one landed; otherwise fall through to the in-memory UUID.
+    try {
+      const won = readFileSync(cache, 'utf8').trim();
+      if (looksValid(won)) { try { unlinkSync(tmp); } catch {} return emit(won); }
+    } catch { /* still nothing on disk / dir unreadable */ }
+    try { unlinkSync(tmp); } catch {}               // best-effort temp cleanup; a locked temp is left, swept by post-compact
+  }
+  emit(id);
+}
+
+main();

package/scripts/snap-build.mjs

@@ -0,0 +1,90 @@
+import { readFileSync } from 'node:fs';
+
+const MAX_SNAP_BYTES = 10485760;          // 10 MiB (v2)
+const V1_MAX_CHARS = 4096;                // handoff-file contract (v1)
+const CAPS = { n: [3, 200], f: [20, 300], d: [10, 300], x: [5, 200] };
+
+const die = (msg) => { process.stderr.write(`SNAP_BUILD_ERROR: ${msg}\n`); process.exit(1); };
+const byteLen = (s) => Buffer.byteLength(s, 'utf8');
+
+// Async write, then exit 0 once the OS has drained it. A synchronous write to a
+// non-blocking stdout pipe throws EAGAIN on large payloads, and process.exit right
+// after an async write truncates the un-flushed tail; the drain callback avoids both.
+function writeOut(s) { process.stdout.write(s + '\n', () => process.exit(0)); }
+
+// filter empties, dedup (first wins), Unicode-safe per-element truncation, head-drop to count cap
+function normArray(raw, [cap, elemCap]) {
+  const arr = Array.isArray(raw) ? raw : [];
+  const seen = new Set(); const out = [];
+  for (const item of arr) {
+    if (typeof item !== 'string') continue;
+    const t = item.trim();
+    if (!t || seen.has(t)) continue;
+    seen.add(t);
+    out.push(Array.from(t).slice(0, elemCap).join(''));
+  }
+  while (out.length > cap) out.shift();
+  return out;
+}
+
+// back off one unit if the boundary would keep a lone high surrogate
+function surrogateSafe(str, n) {
+  if (n > 0 && n <= str.length) {
+    const code = str.charCodeAt(n - 1);
+    if (code >= 0xD800 && code <= 0xDBFF) return n - 1;
+  }
+  return n;
+}
+
+let input;
+try { input = readFileSync(0, 'utf8'); } catch (e) { die(`cannot read stdin: ${e.code || e.message}`); }
+
+let obj;
+try { obj = JSON.parse(input); } catch { die('malformed JSON on stdin'); }
+if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) die('stdin must be a JSON object');
+
+for (const k of ['ph', 'c', 's']) {
+  if (typeof obj[k] !== 'string' || obj[k] === '') die(`missing or empty scalar: ${k}`);
+}
+
+const sys = { ph: obj.ph, c: obj.c, s: obj.s };
+const ops = { n: normArray(obj.n, CAPS.n), f: normArray(obj.f, CAPS.f) };
+const mem = { d: normArray(obj.d, CAPS.d), x: normArray(obj.x, CAPS.x) };
+const pr = typeof obj.pr === 'string' ? obj.pr : '';
+
+if (pr === '') {
+  // ---- v1: 4096-char cap, drop oldest of mem.d / ops.f ----
+  const snap = { v: 1, sys, ops, mem };
+  let line = JSON.stringify(snap);
+  while (line.length > V1_MAX_CHARS && (mem.d.length || ops.f.length)) {
+    if (mem.d.length >= ops.f.length && mem.d.length) mem.d.shift();
+    else ops.f.shift();
+    line = JSON.stringify(snap);
+  }
+  writeOut(line);
+} else {
+  // ---- v2: 10 MiB cap, truncate raw pr before serialize ----
+  const skeletonBytes = byteLen(JSON.stringify({ v: 2, sys, ops, mem, pr: '' }));
+  if (skeletonBytes > MAX_SNAP_BYTES) die('skeleton exceeds cap even without prose');
+
+  // total serialized bytes for a candidate pr value (skeleton already counts the two empty-value quotes)
+  const totalBytes = (val) => skeletonBytes + byteLen(JSON.stringify(val)) - 2;
+
+  let keep = pr.length;
+  if (totalBytes(pr) > MAX_SNAP_BYTES) {
+    let lo = 0, hi = pr.length, best = 0;
+    for (let i = 0; i < 64 && lo <= hi; i++) {
+      const mid = (lo + hi) >> 1;
+      if (totalBytes(pr.slice(0, mid)) <= MAX_SNAP_BYTES) { best = mid; lo = mid + 1; }
+      else hi = mid - 1;
+    }
+    keep = surrogateSafe(pr, best);
+    // defensive fallback if the search somehow left us over cap
+    if (totalBytes(pr.slice(0, keep)) > MAX_SNAP_BYTES) {
+      keep = surrogateSafe(pr, Math.max(0, Math.floor((MAX_SNAP_BYTES - skeletonBytes - 2) / 6)));
+    }
+  }
+
+  const snap = { v: 2, sys, ops, mem, pr: pr.slice(0, keep) };
+  writeOut(JSON.stringify(snap));
+}

package/scripts/snap-validate.mjs

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+const err = (m) => { process.stderr.write(`SNAP_ERROR: ${m}\n`); process.exit(1); };
+const path = process.argv[2]; if (path === undefined) err('no path provided');
+let raw; try { raw = readFileSync(path, 'utf8'); } catch (e) { err(e.code === 'ENOENT' ? 'file not found' : e.code); }
+if (raw.includes('�')) err('encoding error');
+const trimmed = raw.trim(); if (trimmed.includes('\n')) err('internal newline in payload');
+if (trimmed === '') err('empty file'); if (raw.length > 4096) err('payload too large');
+let snap; try { snap = JSON.parse(trimmed); } catch { err('malformed JSON'); }
+if (typeof snap !== 'object' || snap === null || Array.isArray(snap)) err('root must be a plain object');
+for (const b of ['sys', 'ops', 'mem']) if (typeof snap[b] !== 'object' || snap[b] === null || Array.isArray(snap[b])) err(`missing block: ${b}`);
+const req = { v: snap.v, 'sys.ph': snap.sys.ph, 'sys.c': snap.sys.c, 'sys.s': snap.sys.s, 'ops.n': snap.ops.n, 'ops.f': snap.ops.f, 'mem.d': snap.mem.d, 'mem.x': snap.mem.x };
+const missing = Object.entries(req).filter(([, v]) => v === undefined).map(([k]) => k);
+if (missing.length) { for (const k of missing) process.stderr.write(`SNAP_ERROR: missing: ${k}\n`); process.exit(1); }
+const topAllowed = snap.v === 2 ? ['v', 'sys', 'ops', 'mem', 'pr'] : ['v', 'sys', 'ops', 'mem'];
+const topExtra = Object.keys(snap).find(k => !topAllowed.includes(k)); if (topExtra) err(`unexpected key: ${topExtra}`);
+if (snap.pr !== undefined && typeof snap.pr !== 'string') err('pr must be a string');
+const allow = { sys: ['ph', 'c', 's'], ops: ['n', 'f'], mem: ['d', 'x'] };
+for (const b of ['sys', 'ops', 'mem']) { const extra = Object.keys(snap[b]).find(k => !allow[b].includes(k)); if (extra) err(`unexpected key: ${b}.${extra}`); }
+if (typeof snap.v !== 'number' || !Number.isInteger(snap.v) || snap.v < 1) err('v must be a positive integer'); if (snap.v > 2) err('SNAP_UNKNOWN_VERSION');
+if (!['spec', 'plan', 'impl', 'rev'].includes(snap.sys.ph)) err('ph must be spec|plan|impl|rev');
+const caps = { 'ops.n': [3, 200], 'ops.f': [20, 300], 'mem.d': [10, 300], 'mem.x': [5, 200] };
+for (const [key, [cap, elemCap]] of Object.entries(caps)) {
+  const [blk, sub] = key.split('.'); const arr = snap[blk][sub]; if (!Array.isArray(arr)) err(`${key} must be an array`); if (arr.length > cap) err(`${key} exceeds cap`);
+  arr.forEach((el, i) => { if (typeof el !== 'string' || el.trim() === '') err(`empty element in ${key}[${i}]`); if (JSON.stringify(el).slice(1, -1).length > elemCap) err(`element too long in ${key}[${i}]`); });
+}
+snap.ops.f.forEach((el, i) => {
+  if (el.includes('\\')) err(`backslash in ops.f[${i}]`);
+  const idx = el.lastIndexOf(':'); if (idx <= 0) err(`empty path in ops.f[${i}]`);
+  if (!['C', 'M', 'D'].includes(el.slice(idx + 1))) err(`invalid action code in ops.f[${i}]`);
+});
+if (!/^[0-9a-f]{7,64}$/.test(snap.sys.c)) err('invalid sys.c format'); if (!/^[a-zA-Z0-9._-]+$/.test(snap.sys.s)) err('invalid chars in sys.s');
+process.exit(0);