@elu-labs/elu 0.0.0-stage → 0.1.0

package/lib/editor.mjs

@@ -0,0 +1,165 @@
+import blessed from 'blessed';
+
+// A cursor for the message box: arrows, word and line moves, and a click that puts the cursor
+// where you clicked. blessed's textarea only appends at the end.
+
+const CONTROL = /[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]/g;
+const charAt = (value, index) => String.fromCodePoint(value.codePointAt(index));
+const before = (value, index) => index >= 2 && /[\udc00-\udfff]/.test(value[index - 1]) && /[\ud800-\udbff]/.test(value[index - 2]) ? index - 2 : Math.max(0, index - 1);
+const after = (value, index) => Math.min(value.length, index + (index < value.length ? charAt(value, index).length : 0));
+const defaultWidth = ch => ch === '\t' ? 4 : Math.max(0, blessed.unicode.charWidth(ch, 0));
+const widthOf = (text, charWidth) => { let total = 0; for (const ch of text) total += charWidth(ch); return total; };
+
+// Rows of the value at this width. Each row shows value.slice(start, end); next is where the
+// following row starts: end + 1 after a newline or a space that would not fit, else end.
+export function layout(value, width, charWidth = defaultWidth) {
+  width = Math.max(1, width);
+  const rows = []; let start = 0, col = 0, space = -1, index = 0;
+  while (index < value.length) {
+    const ch = charAt(value, index);
+    if (ch === '\n') { rows.push({ start, end: index, next: index + 1 }); start = index + 1; col = 0; space = -1; index++; continue; }
+    const size = charWidth(ch);
+    if (col + size > width && index > start) {
+      if (ch === ' ') { rows.push({ start, end: index, next: index + 1 }); start = index + 1; col = 0; space = -1; index++; continue; }
+      const cut = space >= start ? space + 1 : index;
+      rows.push({ start, end: cut, next: cut }); start = cut; space = -1; col = widthOf(value.slice(start, index), charWidth);
+      continue;
+    }
+    if (ch === ' ') space = index;
+    col += size; index += ch.length;
+  }
+  rows.push({ start, end: value.length, next: value.length });
+  return rows;
+}
+// The row and column the cursor shows at. At a soft wrap it shows at the start of the next row.
+export function position(value, rows, index, charWidth = defaultWidth) {
+  for (let row = 0; row < rows.length; row++) {
+    const r = rows[row];
+    if (index < r.start) continue;
+    if (index < r.end || row === rows.length - 1 || index === r.end && r.next > r.end) return { row, col: widthOf(value.slice(r.start, Math.min(index, r.end)), charWidth) };
+  }
+  return { row: 0, col: 0 };
+}
+// The index at a row and column: the boundary at or before that column.
+export function indexAt(value, rows, row, col, charWidth = defaultWidth) {
+  const r = rows[Math.max(0, Math.min(rows.length - 1, row))];
+  let index = r.start, used = 0;
+  while (index < r.end) { const ch = charAt(value, index), size = charWidth(ch); if (used + size > col) break; used += size; index += ch.length; }
+  return index;
+}
+const lineStart = (value, index) => value.lastIndexOf('\n', index - 1) + 1;
+const lineEnd = (value, index) => { const end = value.indexOf('\n', index); return end < 0 ? value.length : end; };
+const word = ch => /[\p{L}\p{N}_]/u.test(ch);
+function wordBefore(value, index) {
+  while (index > 0 && !word(charAt(value, before(value, index)))) index = before(value, index);
+  while (index > 0 && word(charAt(value, before(value, index)))) index = before(value, index);
+  return index;
+}
+function wordAfter(value, index) {
+  while (index < value.length && !word(charAt(value, index))) index = after(value, index);
+  while (index < value.length && word(charAt(value, index))) index = after(value, index);
+  return index;
+}
+
+// One key on the editor state { value, cursor, goal }. Returns the next state, or null when the
+// key is not an edit (Enter, Escape and Tab stay with the caller).
+export function editKey(state, ch, key = {}, view = {}) {
+  const { value, cursor } = state, name = key.name;
+  const rows = view.rows ?? layout(value, view.width ?? 80, view.charWidth), charWidth = view.charWidth ?? defaultWidth;
+  const at = (next, goal = null) => ({ value, cursor: Math.max(0, Math.min(value.length, next)), goal });
+  const cut = (from, to) => ({ value: value.slice(0, from) + value.slice(to), cursor: from, goal: null });
+  const vertical = step => {
+    const here = position(value, rows, cursor, charWidth), goal = state.goal ?? here.col, row = here.row + step;
+    if (row < 0) return at(0, goal);
+    if (row >= rows.length) return at(value.length, goal);
+    return at(indexAt(value, rows, row, goal, charWidth), goal);
+  };
+  if (key.meta && (name === 'b' || name === 'left') || key.ctrl && name === 'left') return at(wordBefore(value, cursor));
+  if (key.meta && (name === 'f' || name === 'right') || key.ctrl && name === 'right') return at(wordAfter(value, cursor));
+  if (key.meta && name === 'backspace' || key.ctrl && name === 'w') return cut(wordBefore(value, cursor), cursor);
+  if (key.meta && name === 'd') return cut(cursor, wordAfter(value, cursor));
+  if (name === 'left' || key.ctrl && name === 'b') return at(before(value, cursor));
+  if (name === 'right' || key.ctrl && name === 'f') return at(after(value, cursor));
+  if (name === 'up' || key.ctrl && name === 'p') return vertical(-1);
+  if (name === 'down' || key.ctrl && name === 'n') return vertical(1);
+  if (name === 'home' || key.ctrl && name === 'a') return at(lineStart(value, cursor));
+  if (name === 'end' || key.ctrl && name === 'e') return at(lineEnd(value, cursor));
+  if (name === 'backspace') return cut(before(value, cursor), cursor);
+  if (name === 'delete' || key.ctrl && name === 'd') return cut(cursor, after(value, cursor));
+  if (key.ctrl && name === 'u') return cut(lineStart(value, cursor), cursor);
+  if (key.ctrl && name === 'k') { const end = lineEnd(value, cursor); return cut(cursor, end === cursor ? after(value, cursor) : end); }
+  if (['enter', 'return', 'escape', 'tab'].includes(name) && key.sequence !== '\n') return null;
+  const text = name === 'enter' ? '\n' : typeof ch === 'string' ? ch.replace(CONTROL, '') : '';
+  if (!text || key.ctrl || key.meta) return key.ctrl || key.meta ? state : null;
+  return { value: value.slice(0, cursor) + text + value.slice(cursor), cursor: cursor + text.length, goal: null };
+}
+
+// Gives a blessed textarea the cursor: its own wrapping, scrolling that follows the cursor,
+// the terminal cursor at that spot, and a click that moves it there.
+export function editable(field) {
+  const screen = field.screen;
+  const charWidth = ch => ch === '\t' ? screen.tabc.length : Math.max(0, blessed.unicode.charWidth(ch, 0));
+  field.cursor = field.value.length; field.goal = null;
+  let laid = null;
+  // blessed wraps a textarea one column short, leaving room for the cursor; rows here match it.
+  const width = () => Math.max(1, field.width - field.iwidth - 1 - (field.scrollbar ? 1 : 0));
+  const rows = () => {
+    const w = width();
+    if (laid?.value !== field.value || laid.width !== w) laid = { value: field.value, width: w, rows: layout(field.value, w, charWidth) };
+    return laid.rows;
+  };
+  field.editorView = () => ({ rows: rows(), width: width(), charWidth });
+  // Typing keeps the cursor; a value set from outside puts it at the end.
+  field.setValue = function(value) {
+    if (value != null && value !== this.value) { this.cursor = value.length; this.goal = null; }
+    if (value != null) this.value = value;
+    this.cursor = Math.max(0, Math.min(this.cursor, this.value.length));
+    const list = rows(), content = list.map(row => this.value.slice(row.start, row.end)).join('\n');
+    if (this._editorContent !== content) { this._editorContent = content; this.setContent(content); }
+    const height = Math.max(1, this.height - this.iheight), row = position(this.value, list, this.cursor, charWidth).row;
+    let base = this.childBase || 0;
+    if (row < base) base = row; else if (row >= base + height) base = row - height + 1;
+    this.childBase = Math.max(0, Math.min(base, Math.max(0, list.length - height))); this.childOffset = 0;
+    this._updateCursor();
+  };
+  field.clearValue = field.clearInput = function() { return this.setValue(''); };
+  field._updateCursor = function(get) {
+    if (screen.focused !== this) return;
+    const lpos = get ? this.lpos : this._getCoords(); if (!lpos) return;
+    const { row, col } = position(this.value, rows(), this.cursor, charWidth), program = screen.program;
+    const y = lpos.yi + this.itop + Math.max(0, Math.min(row - (this.childBase || 0), lpos.yl - lpos.yi - this.iheight - 1));
+    const x = Math.min(lpos.xl - 1, lpos.xi + this.ileft + col);
+    if (y !== program.y || x !== program.x) program.cup(y, x);
+  };
+  // Backspace or Delete with text highlighted in the box removes that text. field.selection
+  // gives the highlighted cells { from, to } inside the field, or null.
+  field._listener = function(ch, key = {}) {
+    if (key.name === 'escape') return this._done?.(null, null);
+    const highlighted = ['backspace', 'delete'].includes(key.name) && !key.ctrl && !key.meta ? field.selection?.() : null;
+    const next = highlighted ? cutCells(highlighted.from, highlighted.to) : editKey({ value: this.value, cursor: this.cursor, goal: this.goal }, ch, key, field.editorView());
+    if (!next) return;
+    const changed = next.value !== this.value || next.cursor !== this.cursor;
+    this.value = next.value; this.cursor = next.cursor; this.goal = next.goal;
+    if (changed) { this.setValue(); screen.render(); }
+  };
+  // The text between two screen cells, for copying a selection.
+  const cellIndex = (x, y, lpos = field.lpos) => {
+    if (!lpos) return 0;
+    return indexAt(field.value, rows(), y - lpos.yi - field.itop + (field.childBase || 0), Math.max(0, x - lpos.xi - field.ileft), charWidth);
+  };
+  const cellRange = (from, to) => { const a = cellIndex(from.x, from.y), b = cellIndex(to.x + 1, to.y); return [Math.min(a, b), Math.max(a, b)]; };
+  field.selectText = (from, to) => { const [a, b] = cellRange(from, to); return field.value.slice(a, b); };
+  const cutCells = (from, to) => { const [a, b] = cellRange(from, to); return { value: field.value.slice(0, a) + field.value.slice(b), cursor: a, goal: null }; };
+  // A click puts the cursor at that character; past a wrapped row's end it stays on that row.
+  field.on('click', data => {
+    if (data.button !== 'left' || !field.lpos) return;
+    const list = rows(), row = Math.max(0, Math.min(list.length - 1, data.y - field.lpos.yi - field.itop + (field.childBase || 0)));
+    let index = cellIndex(data.x, data.y);
+    if (index === list[row].end && list[row].next === list[row].end && index > list[row].start && row < list.length - 1) index = before(field.value, index);
+    field.cursor = index; field.goal = null;
+    if (screen.focused !== field) field.focus();
+    if (!field._reading) field.readInput?.();
+    field.setValue(); screen.render();
+  });
+  return field;
+}

package/lib/format.mjs

@@ -0,0 +1,51 @@
+import {quote}from'./util.mjs';
+import {VENDOR_NAMES}from'./vendors.mjs';
+import {botOfKey}from'./bots.mjs';
+import {ADAPTERS}from'./adapters/index.mjs';
+import {uncheckedText}from'./conformance.mjs';
+const names={...VENDOR_NAMES,opencode:'OpenCode',cursor:'Cursor CLI'};
+// The session's own run is the model to a person; the config file still calls it lead.
+const shown=name=>name==='lead'?'model':name;
+// Google's terms on wrapping agy: shown under every Antigravity sign-in row.
+export const ANTIGRAVITY_FAQ="Google's FAQ: wrapping agy in third-party agents is not supported on consumer plans. antigravity.google/docs/faq";
+// What a vendor row still needs, one line each: the owner signs in with its own CLI; the
+// one-time check of a vendor designed from its docs starts by itself.
+export function vendorLines(tool){
+ const lines=[],hint=ADAPTERS[tool.vendor]?.meta.signInHint;
+ if(tool.signedIn===false&&hint){lines.push(...hint.split('\n'));if(tool.vendor==='agy'&&!hint.includes(ANTIGRAVITY_FAQ))lines.push(ANTIGRAVITY_FAQ);}
+ if(tool.conformant===false&&tool.available!==false&&tool.supported!==false)lines.push(uncheckedText(tool.vendor,{version:tool.release??null}));
+ return lines;
+}
+export function formatResult(value,command=''){
+ if(value.help)return value.help;
+ const lines=[];
+ if(value.preview)lines.push('Preview only. Nothing ran and no model credit was used.');
+ if(value.goal)lines.push(`Task: ${value.goal}`);
+ if(value.initialized)lines.push(value.adopted?'ELU Code adopted the committed configuration.':'ELU Code is ready.');
+ if(value.uninstalled)lines.push('ELU Code local state was removed.');
+ if(value.message)lines.push(value.message);
+ for(const line of Array.isArray(value.lines)?value.lines:[])lines.push(String(line));
+ if(value.state)lines.push(`Task ${value.id}: ${value.state}`,value.result?.summary??'');
+ if(value.sandboxHelper)lines.push(value.sandboxHelper.working?'Sandbox helper: outside file writes were contained; network access was denied.':`Sandbox helper: ${value.sandboxHelper.message}`);
+ const vendors=Array.isArray(value.vendors)?value.vendors:value.vendors?Object.values(value.vendors).filter(Boolean):[];
+ for(const tool of vendors){lines.push(`${names[tool.vendor]??tool.vendor}: ${tool.available===false?'not installed':tool.version??tool.support??'unknown'}${tool.versionStatus?` (${tool.versionStatus})`:''}${tool.signedIn===false?' — signed out':''}${tool.reason?` — ${tool.reason}`:''}`);for(const line of vendorLines(tool))lines.push(`  ${line}`);}
+ for(const row of value.unsupportedVendors??[])lines.push(`${names[row.vendor]}: ${row.support}`);
+ // Only the lead entry runs. An older config may still list review entries; bots review now.
+ const lead=value.config?.roles?.lead;if(lead)lines.push(`model: ${names[lead.vendor]??lead.vendor}; ${lead.access}; allowed commands: ${lead.commands.join(', ')||'none'}`);
+ for(const check of value.config?.checks??[])lines.push(`Check ${check.name}: ${check.command.join(' ')}`);
+ for(const file of value.hooks??value.git?.hooks??[])lines.push(`Git hook file: ${file}`);
+ for(const role of value.roles??[]){lines.push(`${shown(role.name)}: ${names[role.vendor]??role.vendor}`);for(const rule of role.rules)lines.push(`  ${rule.rule}: ${rule.enforcement}`);if(role.refusal)lines.push(`  Refused: ${role.refusal}`);}
+ for(const task of value.tasks??[]){lines.push(`Task ${task.id}: ${task.state} — ${task.goal}`);for(const run of task.runs??[])lines.push(`  ${botOfKey(run.role)?`@${botOfKey(run.role)}`:shown(run.role)}: ${names[run.vendor]??run.vendor} ${run.version??''} (${run.versionStatus??'version not recorded'})`);}
+ if(value.tasks?.length===0)lines.push('No tasks yet.');
+ for(const result of value.results??value.evidence?.results??[])lines.push(`${result.name}: ${result.status}`);
+ for(const file of value.writes??[])lines.push(`Will write: ${file}`);
+ for(const file of value.trackedDeletions??[])lines.push(`Tracked deletion: ${file}`);
+ if(value.command)lines.push(value.command);
+ if(value.commit)lines.push(`Commit: ${value.commit}`);
+ if(value.destination)lines.push(`Push destination: ${value.destination.name} ${value.destination.ref}`);
+ if(value.body)lines.push('',value.body);
+ if(value.pr)lines.push(`Draft PR: ${value.pr}`);
+ if(value.nextCommand)lines.push(`To continue: ${value.nextCommand}`);
+ else if(value.needsConfirmation||value.preview||value.files)lines.push(`To continue: elu ${command==='run'?`run ${quote(value.goal??'Describe your task')}`:command} --yes`);
+ return lines.filter(line=>line!=='').join('\n')+'\n';
+}

package/lib/git.mjs

@@ -0,0 +1,173 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execute, refuse, noSymlinks, hash, findBin } from './util.mjs';
+
+export function git(root, args, options = {}) {
+  return execute('git', ['--no-pager', '-C', root, ...args], { ...options, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0', ...options.env } });
+}
+export function prepareGit(repo,root,args){
+  if(!['add','worktree'].includes(args[0]))refuse('Only Git preparation can use an empty hook directory.');
+  const hooks=path.join(repo.state,'empty-hooks');noSymlinks(hooks);fs.mkdirSync(hooks,{recursive:true,mode:0o700});
+  if(fs.readdirSync(hooks).length)refuse('The Git preparation hook directory is not empty.');
+  return git(root,['-c',`core.hooksPath=${hooks}`,...args]);
+}
+export function located(root, common) {
+  return { root, common, state: path.join(common, 'elu-code'), worktrees: path.join(path.dirname(root), `${path.basename(root)}.elu-code`) };
+}
+export function repository(cwd) {
+  const root = fs.realpathSync(git(cwd, ['rev-parse', '--show-toplevel']).stdout.trim());
+  return located(root, fs.realpathSync(path.resolve(root, git(root, ['rev-parse', '--git-common-dir']).stdout.trim())));
+}
+// Views show the branch on every redraw. Reading HEAD avoids starting a Git process each time.
+export function currentBranch(root) {
+  try {
+    const dot = path.join(root, '.git'), stat = fs.lstatSync(dot);
+    const dir = stat.isDirectory() ? dot : stat.isFile() ? path.resolve(root, /^gitdir: (.+)$/m.exec(fs.readFileSync(dot, 'utf8'))?.[1].trim() ?? '') : null;
+    const value = dir && fs.lstatSync(path.join(dir, 'HEAD')).isFile() ? fs.readFileSync(path.join(dir, 'HEAD'), 'utf8').trim() : '';
+    if (value.startsWith('ref: refs/heads/')) return value.slice(16);
+    if (/^[0-9a-f]{40,64}$/.test(value)) return '';
+  } catch { /* Unusual layouts fall back to Git. */ }
+  return git(root, ['branch', '--show-current']).stdout.trim();
+}
+export function findRepository(cwd) {
+  if (!findBin('git')) return null;
+  const result = git(cwd, ['rev-parse', '--show-toplevel'], { allowFailure: true });
+  if (result.status === 0) return repository(cwd);
+  if (/not a git repository/i.test(result.stderr)) return null;
+  refuse('The project history could not be read.', { reason: result.stderr.trim().slice(0, 1000) });
+}
+export function head(root) { return git(root, ['rev-parse', '--verify', 'HEAD']).stdout.trim(); }
+// The commit a named local branch points at (a task placed on a branch bases on it).
+export function branchHead(root, branch) {
+  const result = git(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], { allowFailure: true });
+  if (result.status !== 0) refuse(`Branch not found: ${branch}`);
+  return result.stdout.trim();
+}
+export function baseFile(root, base, file, { optional = false } = {}) {
+  const r = git(root, ['show', `${base}:${file}`], { allowFailure: optional });
+  return r.status === 0 ? r.stdout : null;
+}
+export function tracked(root, base) {
+  return git(root, ['ls-tree', '-r', '-z', '--name-only', base]).stdout.split('\0').filter(Boolean);
+}
+function hookSource(repo, root) {
+  const configured = git(root, ['config', '--path', '--get', 'core.hooksPath'], { allowFailure: true }).stdout.trim();
+  const active = configured ? path.resolve(root, configured) : path.join(repo.common, 'hooks');
+  const relative = path.relative(root, active);
+  const inside = configured && !path.isAbsolute(configured) && relative && !relative.startsWith('..') && relative.split(path.sep)[0]!=='.git' && !path.isAbsolute(relative);
+  const source = inside ? path.join(root, relative.split(path.sep)[0]) : active;
+  const files = [];
+  function walk(dir) {
+    if (!fs.existsSync(dir)) return;
+    noSymlinks(dir);
+    for (const name of fs.readdirSync(dir).sort()) {
+      const file=path.join(dir,name); noSymlinks(file);const stat=fs.statSync(file);
+      if(stat.isDirectory())walk(file);
+      else if(stat.isFile()&&!name.endsWith('.sample'))files.push([path.relative(source,file),hash(fs.readFileSync(file)),stat.mode&0o777]);
+    }
+  }
+  walk(source);
+  return { source, active, relative: inside ? relative.split(path.sep)[0] : null, files, digest: hash(JSON.stringify({ configured, files })) };
+}
+export function assertGitSafe(repo, { worktree = repo.root, expectedHooks } = {}) {
+  const fsmonitor = git(repo.root, ['config', '--get', 'core.fsmonitor'], { allowFailure: true }).stdout.trim();
+  if (fsmonitor && fsmonitor !== 'false') refuse('Git filesystem monitors can execute programs. Disable the monitor before starting a checked task.');
+  const source=hookSource(repo,worktree);
+  const defaultGuard=path.join(repo.common,'hooks','pre-push');noSymlinks(defaultGuard);
+  const hookDigest=hash(JSON.stringify([source.digest,fs.existsSync(defaultGuard)?hash(fs.readFileSync(defaultGuard)):null]));
+  if(expectedHooks && hookDigest!==expectedHooks)refuse('Git hooks changed after the preview. Review the hooks before continuing.');
+  const globalAttributes = git(worktree, ['config', '--path', '--get', 'core.attributesFile'], { allowFailure: true }).stdout.trim();
+  const attrs = git(worktree, ['ls-files','-z', '--cached', '--others', '--exclude-standard', '--', '.gitattributes', '**/.gitattributes', '.gitmodules']).stdout.split('\0').filter(Boolean);
+  if(attrs.includes('.gitmodules')||fs.existsSync(path.join(worktree,'.gitmodules')))refuse('Submodules are not supported for checked tasks.');
+  const defaults=['GIT_ATTR_SYSTEM','GIT_ATTR_GLOBAL'].map(name=>git(worktree,['var',name],{allowFailure:true})).filter(row=>row.status===0).map(row=>row.stdout.trim());
+  for(const file of new Set([path.join(repo.common,'info/attributes'),path.join(worktree,'.gitattributes'),...attrs.map(name=>path.join(worktree,name)),...defaults,...(globalAttributes?[path.resolve(worktree,globalAttributes)]:[])])){
+    if(!fs.existsSync(file))continue;if(file.startsWith(worktree+path.sep))noSymlinks(file);
+    for(const line of fs.readFileSync(file,'utf8').split('\n')){
+      if(/^\s*(?:#|$)/.test(line))continue;
+      const tokens=line.match(/"(?:[^"\\]|\\.)*"|\S+/g)??[];
+      for(const token of tokens.slice(1)){
+        const match=/^(filter|diff|merge)=(.+)$/.exec(token);if(!match)continue;
+        const [,kind,name]=match;if(kind==='merge'&&['text','binary','union'].includes(name))continue;
+        const keys=kind==='filter'?['clean','smudge','process']:kind==='diff'?['command','textconv']:['driver'];
+        if(keys.some(key=>git(worktree,['config','--get',`${kind}.${name}.${key}`],{allowFailure:true}).stdout.trim()))refuse(`Git attribute ${kind}=${name} enables an executable driver.`);
+      }
+    }
+  }
+  return { hooks:source.files.map(([file])=>path.join(source.source,file)),hookDigest,protectedPaths:source.relative?[source.relative]:[],hookSource:source };
+}
+export function assertTaskGitSafe(repo,task){
+  assertGitSafe(repo,{expectedHooks:task.hookDigest});
+  return assertGitSafe(repo,{worktree:task.worktree,expectedHooks:task.worktreeHookDigest??task.hookDigest});
+}
+export function snapshotHooks(repo, task, helper=findBin('codex')) {
+  const inspected=assertGitSafe(repo,{expectedHooks:task.hookDigest});
+  assertTaskGitSafe(repo,task);
+  const folder=path.join(repo.state,'tasks',task.id,'hooks');noSymlinks(folder);fs.mkdirSync(folder,{recursive:true,mode:0o700});
+  // Keep push guards, including the common-directory guard when a hook manager is configured.
+  const sources=[inspected.hookSource];
+  const defaultGuard=path.join(repo.common,'hooks','pre-push');
+  const guards=[...new Set([...sources.map(s=>path.join(s.active,'pre-push')),defaultGuard])].filter(file=>fs.existsSync(file));
+  if(guards.length&&!helper)refuse('A Codex sandbox helper is required to run pre-push guards safely.');
+  const copied=[];
+  for(const [index,guard] of guards.entries()){
+    noSymlinks(guard);const source=sources.find(s=>guard.startsWith(s.source+path.sep));const from=source?.source??path.dirname(guard);const to=path.join(folder,`source-${index}`);
+    fs.cpSync(from,to,{recursive:true,filter:file=>!file.endsWith('.sample')});
+    copied.push(path.join(to,path.relative(from,guard)));
+  }
+  const dispatcher=path.join(folder,'pre-push');
+  fs.writeFileSync(dispatcher,`#!${process.execPath}\nimport fs from 'node:fs';import os from 'node:os';import path from 'node:path';import{spawnSync}from'node:child_process';import{sandboxArgs}from ${JSON.stringify(new URL('./sandbox.mjs',import.meta.url).href)};import{agentEnv,killGroup}from ${JSON.stringify(new URL('./process.mjs',import.meta.url).href)};const input=fs.readFileSync(0);for(const hook of ${JSON.stringify(copied)}){const scratch=fs.mkdtempSync(path.join(${JSON.stringify(folder)},'tmp-'));let result;try{fs.mkdirSync(path.join(scratch,'codex-home'),{mode:0o700});fs.mkdirSync(path.join(scratch,'tmp'),{mode:0o700});const args=sandboxArgs({helper:${JSON.stringify(helper)},cwd:process.cwd(),writablePaths:[],scratch,program:hook,args:process.argv.slice(2),readPaths:[${JSON.stringify(repo.common)},path.join(process.cwd(),'.git')],deniedPaths:['.ssh','.aws','.config','.claude','.codex','.netrc','.npmrc'].map(name=>path.join(os.homedir(),name))});result=spawnSync(${JSON.stringify(helper)},args,{input,env:{...agentEnv(),CODEX_HOME:path.join(scratch,'codex-home'),TMPDIR:path.join(scratch,'tmp'),GIT_OPTIONAL_LOCKS:'0',GIT_TERMINAL_PROMPT:'0'},stdio:['pipe','inherit','inherit'],detached:true,timeout:120000});if(result.pid)killGroup(result.pid,'SIGKILL');}finally{fs.rmSync(scratch,{recursive:true,force:true});}if(result.status!==0)process.exit(result.status??1);}\n`,{mode:0o700});
+  return folder;
+}
+export function hooksSnapshotDigest(folder) {
+  noSymlinks(folder);const rows=[];
+  function visit(dir){for(const name of fs.readdirSync(dir).sort()){const file=path.join(dir,name);noSymlinks(file);const stat=fs.statSync(file);if(stat.isDirectory())visit(file);else rows.push([path.relative(folder,file),stat.mode&0o777,hash(fs.readFileSync(file))]);}}
+  visit(folder);return hash(JSON.stringify(rows));
+}
+export function assertPublishingHooks(repo,task){
+  const expected=path.join(repo.state,'tasks',task.id,'hooks');
+  if(task.hooksDirectory!==expected||!task.hooksSnapshotDigest||hooksSnapshotDigest(expected)!==task.hooksSnapshotDigest)refuse('The saved hooks are missing or changed. Start a new task before publishing.');
+  assertTaskGitSafe(repo,task);
+  return expected;
+}
+// A task's changes against its base, for every place. In the owner's real
+// checkout (place here) the ignored files were there before the task, so they are not
+// counted; a task worktree starts clean, so anything ignored there is the task's output.
+export function taskChanges(task) { return changed(task.worktree, task.base, { ignored: task.place?.kind !== 'here' }); }
+export function changed(root, base, { ignored: withIgnored = true } = {}) {
+  const args = ['diff', '--no-ext-diff', '--no-textconv', '--no-renames'];
+  const names = git(root, [...args, '--name-only', '-z', base, '--']).stdout.split('\0').filter(Boolean);
+  const untracked = git(root, ['ls-files', '--others', '--exclude-standard', '-z']).stdout.split('\0').filter(Boolean);
+  const ignored = withIgnored ? git(root, ['ls-files', '--others', '--ignored', '--exclude-standard', '-z']).stdout.split('\0').filter(Boolean) : [];
+  const paths = [...new Set([...names, ...untracked, ...ignored])].sort();
+  const counts = git(root, [...args, '--numstat', '-z', base, '--']).stdout.split('\0').filter(Boolean);
+  let lines = 0;
+  let binary = false;
+  for (const row of counts) {
+    const [added, removed] = row.split('\t');
+    if (added === '-' || removed === '-') binary = true;
+    else lines += Number(added) + Number(removed);
+  }
+  const entries = [];
+  for (const file of paths) {
+    const full = path.join(root, file);
+    let bytes = null;
+    let mode = null;
+    try {
+      noSymlinks(full);
+      const stat = fs.statSync(full);
+      if (!stat.isFile()) refuse(`Changed path is not a regular file: ${file}`);
+      if (stat.size > 4 * 1024 * 1024) refuse(`Changed file is too large to inspect: ${file}`);
+      bytes = fs.readFileSync(full); mode = stat.mode & 0o777;
+      if (untracked.includes(file) || ignored.includes(file)) {
+        if (bytes.includes(0)) binary = true;
+        else lines += bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0;
+      }
+    } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    entries.push([file, bytes ? hash(bytes) : null, mode]);
+  }
+  return { paths, lines, binary, ignored, digest: hash(JSON.stringify(entries)) };
+}
+export function diff(root, base) {
+  const value = git(root, ['diff', '--no-ext-diff', '--no-textconv', '--no-renames', base, '--']).stdout;
+  return value;
+}

package/lib/init.mjs

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { defaultConfig,parseConfig } from './config.mjs';
+import { stringifyYaml } from './yaml.mjs';
+import { atomic, hash, mkdir, noSymlinks, readJson, refuse } from './util.mjs';
+import { NOT_APPROVED, approveRemoved, approveSaved, trustedText } from './project-trust.mjs';
+import { detect } from './detect.mjs';
+import { event, tasks } from './state.mjs';
+import { git, assertGitSafe,baseFile,head } from './git.mjs';
+import { processIdentity } from './process.mjs';
+import { checkPlace } from './modes.mjs';
+
+const BLOCK = '<!-- elu-code:start -->\nUse the task policy in .elu-code/config.yaml. Leave policy and check definitions unchanged.\nOnly the owner may approve publishing.\n<!-- elu-code:end -->';
+const IMPORT = '@.elu-code/config.yaml';
+export function inferChecks(root){
+  const file=path.join(root,'package.json');noSymlinks(file);
+  if(fs.existsSync(file)){
+    let pkg;try{pkg=JSON.parse(fs.readFileSync(file,'utf8'));}catch{refuse('package.json is not valid JSON. Fix it before init.');}
+    const manager=/^(pnpm|yarn|bun)@/.exec(pkg.packageManager??'')?.[1]??'npm';
+    return ['test','build'].filter(name=>typeof pkg.scripts?.[name]==='string'&&pkg.scripts[name].trim()).map(name=>({name:name==='test'?'tests':'build',command:name==='test'?[manager,'test']:[manager,'run',name]}));
+  }
+  if(fs.existsSync(path.join(root,'go.mod')))return[{name:'tests',command:['go','test','./...']}];
+  if(fs.existsSync(path.join(root,'Cargo.toml')))return[{name:'tests',command:['cargo','test']}];
+  if(['pytest.ini','conftest.py'].some(file=>fs.existsSync(path.join(root,file))))return[{name:'tests',command:['python3','-m','pytest']}];
+  return [];
+}
+export function initPlan(repo, proposedConfig) {
+  noSymlinks(path.join(repo.root, '.elu-code'));
+  const manifestFile = path.join(repo.state, 'manifest.json');
+  if (fs.existsSync(manifestFile)) {
+    if (fs.existsSync(path.join(repo.root, '.elu-code/config.yaml'))) return { initialized: true, writes: [] };
+    const previous = readJson(manifestFile);
+    if (previous.version !== 1 || !Array.isArray(previous.files) || previous.files.some(file => !['.elu-code/config.yaml', 'AGENTS.md', 'CLAUDE.md'].includes(file.path))) refuse('Project setup history is invalid. Review it before restoring settings.');
+    const committed = baseFile(repo.root, head(repo.root), '.elu-code/config.yaml', { optional: true });
+    const config = committed ? parseConfig(committed) : proposedConfig ? parseConfig(stringifyYaml(proposedConfig)) : defaultConfig();
+    if (!committed && !proposedConfig) config.checks = inferChecks(repo.root);
+    const file = { path: '.elu-code/config.yaml', content: stringifyYaml(config), kind: 'file' };
+    return { initialized: false, config, fromHistory: Boolean(committed), files: [file], keepFiles: previous.files.filter(row => row.path !== file.path), worktrees: previous.worktrees, writes: [path.join(repo.root, file.path), manifestFile], vendors: detect(repo.root).map(({ bin, ...value }) => value), message: 'Restore the missing project settings. Existing tasks and marked instructions are kept.' };
+  }
+  const existing=path.join(repo.root,'.elu-code/config.yaml');noSymlinks(existing);
+  if(fs.existsSync(existing)){
+    const text=fs.readFileSync(existing,'utf8');if(baseFile(repo.root,head(repo.root),'.elu-code/config.yaml',{optional:true})!==text)refuse('Commit the existing .elu-code/config.yaml before adopting it.');
+    // A settings file that came with the folder is adopted only as the owner approved it on this machine.
+    if(trustedText(repo.root,'config.yaml')!==text)refuse(NOT_APPROVED);
+    return{initialized:false,adopted:true,adoptedHash:hash(text),config:parseConfig(text),files:[],writes:[repo.state],vendors:detect(repo.root).map(({bin,...row})=>row),message:'Use the committed configuration and create local run state.'};
+  }
+  const config = proposedConfig ? parseConfig(stringifyYaml(proposedConfig)) : defaultConfig();
+  // The scripts found in the folder become checks, which run inside the check sandbox. The lead
+  // gets no shell commands from them: roles.lead.commands holds only what the owner writes.
+  if (!proposedConfig) config.checks=inferChecks(repo.root);
+  const files = [{ path: '.elu-code/config.yaml', content: stringifyYaml(config), kind: 'file' }];
+  for (const [file, addition] of [['AGENTS.md', BLOCK], ['CLAUDE.md', IMPORT]]) {
+    const full = path.join(repo.root, file); noSymlinks(full);
+    if(file==='CLAUDE.md'&&!fs.existsSync(full))continue;
+    const before = fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : '';
+    if (before.includes('<!-- elu-code:') || before.split(/\r?\n/).includes(IMPORT)) refuse(`${file} already contains a ELU Code block or import. Resolve it before init.`);
+    const suffix = `${before && !before.endsWith('\n') ? '\n' : ''}${before ? '\n' : ''}${addition}\n`;
+    files.push({ path: file, content: before + suffix, addition: suffix, created: !fs.existsSync(full), beforeHash: hash(before), kind: 'block' });
+  }
+  return { initialized: false, config, vendors: detect(repo.root).map(({ bin, ...value }) => value), files, writes: [...files.map((file) => path.join(repo.root, file.path)), `${repo.state}/`], message: config.checks.length?'Review the proposed checks before committing the configuration.':'No checks were found for this repository. Add checks to .elu-code/config.yaml before starting a task.' };
+}
+export function applyInit(repo, plan) {
+  if (plan.initialized) return plan;
+  if(plan.adopted&&hash(fs.readFileSync(path.join(repo.root,'.elu-code/config.yaml'),'utf8'))!==plan.adoptedHash)refuse('The committed configuration changed after the preview.');
+  for (const file of plan.files) {
+    const full = path.join(repo.root, file.path); noSymlinks(full);
+    if (file.kind === 'block') {
+      const current = fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : '';
+      if (hash(current) !== file.beforeHash) refuse(`${file.path} changed since the write preview.`);
+    } else if (fs.existsSync(full)) refuse(`${file.path} appeared since the write preview.`);
+  }
+  mkdir(repo.state);
+  atomic(path.join(repo.state, 'manifest.json'), { version: 1, files: [...(plan.keepFiles ?? []), ...plan.files.map(({ content, ...file }) => ({ ...file, contentHash: hash(content) }))], worktrees: plan.worktrees ?? [] });
+  // Settings ELU Code proposed and the owner confirmed are approved by this save. Ones
+  // restored from the project's history are not: they are asked about like any other.
+  for (const file of plan.files) { if (file.path === '.elu-code/config.yaml' && !plan.fromHistory) approveSaved(repo.root, 'config.yaml', file.content); atomic(path.join(repo.root, file.path), file.content); }
+  event(repo, 'initialized');
+  return { initialized: true,adopted:Boolean(plan.adopted), writes: plan.writes, vendors: plan.vendors, message: plan.adopted?'Local state is ready. The committed files are unchanged.':`${plan.message} Commit the generated files after review.` };
+}
+export function uninstallPlan(repo) {
+  if(!fs.existsSync(path.join(repo.state,'manifest.json')) && !fs.existsSync(path.join(repo.state,'tasks')))return{installed:false,edits:[],worktrees:[],writes:[],message:'There is no local installation state to remove.'};
+  const manifest = fs.existsSync(path.join(repo.state, 'manifest.json')) ? readJson(path.join(repo.state, 'manifest.json')) : { version: 1, files: [] };
+  if (manifest.version !== 1 || !Array.isArray(manifest.files) || manifest.files.some((f) => !['.elu-code/config.yaml', 'AGENTS.md', 'CLAUDE.md'].includes(f.path))) refuse('Uninstall manifest is invalid.');
+  const active = tasks(repo).filter((task) => ['running', 'preparing'].includes(task.state));
+  if (active.length) refuse('Stop or recover running tasks before uninstalling.');
+  for (const file of fs.readdirSync(repo.state).filter((name) => /^task-[0-9]+\.lock$/.test(name) || name === 'view.lock')) {
+    const owner = readJson(path.join(repo.state, file));
+    if (processIdentity(owner.pid) === owner.identity) refuse('A project view or task is still running. Close it before uninstalling.');
+  }
+  for (const task of tasks(repo)) {
+    const file = path.join(repo.state, 'tasks', task.id, 'process.json');
+    if (!fs.existsSync(file)) continue;
+    const record = readJson(file);
+    if (record.pid && processIdentity(record.pid) === record.identity) refuse('A task process is still running. Use status --recover before uninstalling.');
+  }
+  // A session placed here edits the real checkout, which stays: it is not a worktree ELU Code made.
+  const worktrees = tasks(repo).filter(task => task.kind !== 'conversation' && checkPlace(task.place ?? null, { mode: 'full' }).kind !== 'here').map((task) => task.worktree).filter((file) => fs.existsSync(file));
+  if (worktrees.length) assertGitSafe(repo);
+  for (const folder of worktrees) {
+    noSymlinks(folder);
+    if (git(folder, ['status', '--porcelain']).stdout.trim()) refuse(`Worktree has uncommitted changes: ${folder}. Save them before uninstalling.`);
+  }
+  const edits = [];
+  for (const file of manifest.files) {
+    const full = path.join(repo.root, file.path); noSymlinks(full);
+    if (!fs.existsSync(full)) continue;
+    const current = fs.readFileSync(full, 'utf8');
+    if (file.kind === 'file') edits.push({ file: full, remove: true });
+    else {
+      if (!current.includes(file.addition) || current.indexOf(file.addition) !== current.lastIndexOf(file.addition)) refuse(`${file.path}'s marked addition changed. Remove it manually before uninstalling.`);
+      const content = current.replace(file.addition, '');
+      edits.push({ file: full, content, remove: file.created && !content });
+    }
+  }
+  const trackedDeletions=edits.filter(edit=>edit.remove&&git(repo.root,['ls-files','--error-unmatch','--',path.relative(repo.root,edit.file)],{allowFailure:true}).status===0).map(edit=>path.relative(repo.root,edit.file));
+  return { edits, worktrees,trackedDeletions, writes: [...edits.map((x) => x.file), ...worktrees, repo.state], message: `Removes generated files and local run history. Task branches and user edits outside marked additions are kept.${trackedDeletions.length?' Tracked files will be deleted; review and commit these removals.':''}` };
+}
+export function applyUninstall(repo, plan) {
+  if(plan.installed===false)return{uninstalled:true,trackedDeletions:[],message:plan.message};
+  // Removed from inside, so a worktree of another repository a session edited goes too.
+  for (const folder of plan.worktrees) git(folder, ['worktree', 'remove', folder]);
+  // Settings the owner removes here are gone by his word: none stays in force for the folder.
+  for (const edit of plan.edits) { if (!edit.remove) { atomic(edit.file, edit.content); continue; } if (path.relative(repo.root, edit.file) === path.join('.elu-code', 'config.yaml')) approveRemoved(repo.root, 'config.yaml'); fs.unlinkSync(edit.file); }
+  const configDir = path.join(repo.root, '.elu-code');
+  if (fs.existsSync(configDir) && fs.readdirSync(configDir).length === 0) fs.rmdirSync(configDir);
+  noSymlinks(repo.state); fs.rmSync(repo.state, { recursive: true });
+  if (fs.existsSync(repo.worktrees) && fs.readdirSync(repo.worktrees).length === 0) fs.rmdirSync(repo.worktrees);
+  return { uninstalled: true, keptBranches: true,trackedDeletions:plan.trackedDeletions,message:plan.message };
+}