harness-everything 0.2.2 → 0.4.0

package/plugins/harness-everything/skills/harness-everything/scripts/bootstrap.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const {
+  getWorkspaceRoot,
+  getSessionId,
+  getSessionDir,
+  writeCurrentSession,
+  pruneStaleSessions,
+} = require('../../hooks/scripts/lib/harness-state');
+
+console.log("Bootstrapping Harness Skills OS...");
+
+// SessionStart hooks receive a payload with session_id via stdin, same as
+// every other hook. Read it synchronously up front - bootstrap has no
+// tool-call latency to protect, so there's no fast-path tradeoff here - but
+// skip entirely on an interactive TTY (manual run) where reading fd 0 would
+// just hang waiting for input that's never coming.
+let payload = null;
+if (!process.stdin.isTTY) {
+  try {
+    const raw = fs.readFileSync(0, 'utf8');
+    payload = JSON.parse(raw);
+  } catch (err) {
+    // No payload piped in, or invalid JSON - fall back to 'default'.
+  }
+}
+const sessionId = getSessionId(payload);
+
+const root = getWorkspaceRoot(payload);
+
+// Guard: only materialize state in a workspace that actually has Harness
+// installed. Without this, running a Claude session in any random folder
+// (or using the agent for non-engineering chat) would still create
+// state directories and session files there. A workspace counts as
+// managed when it is a git repo AND carries at least one Harness install
+// marker - or IS the harness-everything source repo itself (so manual
+// VERIFICATION.md runs keep working after a fresh clone).
+function isManagedWorkspace(wsRoot) {
+  if (!fs.existsSync(path.join(wsRoot, '.git'))) return false;
+  if (fs.existsSync(path.join(wsRoot, 'harness-everything', 'scripts', 'bootstrap.js'))) return true;
+  const markers = [
+    path.join(wsRoot, '.claude', 'settings.json'),
+    path.join(wsRoot, '.cursorrules'),
+    path.join(wsRoot, '.github', 'copilot-instructions.md'),
+    path.join(wsRoot, 'AGENTS.md'),
+    path.join(wsRoot, '.continue', 'rules', 'harness.md'),
+    path.join(wsRoot, '.hermes.md'),
+  ];
+  return markers.some(m => fs.existsSync(m));
+}
+
+if (!isManagedWorkspace(root)) {
+  // Stay completely silent: hooks must never surprise the user with files
+  // or output in workspaces Harness was never installed into.
+  process.exit(0);
+}
+
+// Nothing purges old session directories the way an OS temp dir would -
+// drop ones untouched for a while so .claude/harness-everything/state/sessions/ doesn't
+// grow forever.
+pruneStaleSessions(root);
+
+// The manual escape hatch (reset-circuit-breaker.js) and any CLI tool that
+// can't see a session_id, resolve "current session" through
+// this pointer.
+writeCurrentSession(root, sessionId);
+
+const harnessDir = getSessionDir(root, sessionId);
+
+// The Rule of 3 circuit breaker (hooks/scripts/rule-of-3.js) locks all
+// Bash/Edit/Write calls once tripped; the only in-session exits are a valid
+// zoom-out reflection report or a human reset. A new SessionStart means the
+// human has taken over (new session, /clear, /compact) and reviewed the
+// situation, so it's safe to clear here. The stale reflection report goes
+// with it - it belongs to the previous loop, not this session.
+const circuitBreakerFile = path.join(harnessDir, 'rule-of-3-state.json');
+if (fs.existsSync(circuitBreakerFile)) {
+  try {
+    fs.unlinkSync(circuitBreakerFile);
+    console.log("Rule of 3 circuit breaker state cleared for new session.");
+  } catch (err) {
+    // Ignore; worst case the breaker stays tripped until manually reset.
+  }
+}
+const zoomOutReportFile = path.join(harnessDir, 'zoom-out-report.md');
+if (fs.existsSync(zoomOutReportFile)) {
+  try {
+    fs.unlinkSync(zoomOutReportFile);
+  } catch (err) {
+    // Ignore; rule-of-3.js already rejects reports older than the last failure.
+  }
+}
+
+// Same reasoning: a stale subagent-scope baseline from a previous session
+// would make the first Task burst of this session diff against the wrong
+// starting point.
+const subagentScopeFile = path.join(harnessDir, 'subagent-scope-state.json');
+if (fs.existsSync(subagentScopeFile)) {
+  try {
+    fs.unlinkSync(subagentScopeFile);
+  } catch (err) {
+    // Ignore.
+  }
+}
+
+// Self-heal audit: report missing platform integration touchpoints so the
+// model (per harness-everything SKILL.md) repairs them via self-heal.js.
+// Audit-and-report only - bootstrap never writes these files itself, so a
+// user who intentionally removed one isn't fought every session start.
+try {
+  const MARKER = 'Harness OS Guidance (Advisory)';
+  const HOOK_ID = 'harness:pre:bootstrap';
+  const workspaceRoot = getWorkspaceRoot(payload);
+  const contains = (p, needle) => {
+    try { return fs.readFileSync(p, 'utf8').includes(needle); } catch (e) { return false; }
+  };
+
+  const isClaudeEnv = process.env.CLAUDE_CODE === 'true' || process.env.SHELL?.includes('claude-code') || false;
+  const isCursorEnv = process.env.TERM_PROGRAM === 'cursor' || process.env.CURSOR_SANDBOX !== undefined || false;
+  const isCopilotEnv = process.env.GITHUB_COPILOT_CHAT === 'true' || process.env.COPILOT_AGENT === '1' || process.env.AI_AGENT?.includes('copilot') || process.env.TERM_PROGRAM === 'vscode' || process.env.VSCODE_PID !== undefined || false;
+
+  const hasClaude = fs.existsSync(path.join(workspaceRoot, '.claude'));
+  const hasCursor = fs.existsSync(path.join(workspaceRoot, '.cursorrules')) || fs.existsSync(path.join(workspaceRoot, '.cursor'));
+  const hasCopilot = fs.existsSync(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
+  const hasCodex = fs.existsSync(path.join(workspaceRoot, 'AGENTS.md'));
+
+  const activePlatforms = {
+    claude: isClaudeEnv || hasClaude,
+    cursor: isCursorEnv || hasCursor,
+    copilot: (!isClaudeEnv && !isCursorEnv && isCopilotEnv) || hasCopilot,
+    codex: hasCodex
+  };
+
+  // If no platforms are active, fallback to current environment
+  const hasAnyActive = Object.values(activePlatforms).some(v => v);
+  if (!hasAnyActive) {
+    if (isClaudeEnv) {
+      activePlatforms.claude = true;
+    } else if (isCursorEnv) {
+      activePlatforms.cursor = true;
+    } else {
+      activePlatforms.copilot = true;
+    }
+  }
+
+  const missing = [];
+  if (activePlatforms.claude && !contains(path.join(workspaceRoot, '.claude', 'settings.json'), HOOK_ID)) {
+    missing.push('.claude/settings.json (Claude Code hooks)');
+  }
+  if (activePlatforms.cursor && !contains(path.join(workspaceRoot, '.cursorrules'), MARKER)) {
+    missing.push('.cursorrules (Cursor)');
+  }
+  if (activePlatforms.copilot && !contains(path.join(workspaceRoot, '.github', 'copilot-instructions.md'), MARKER)) {
+    missing.push('.github/copilot-instructions.md (Copilot)');
+  }
+  if (activePlatforms.codex && !contains(path.join(workspaceRoot, 'AGENTS.md'), MARKER)) {
+    missing.push('AGENTS.md (Codex)');
+  }
+
+  // Identity, not path: __dirname/../.. is the INSTALLED copy's root, so an
+  // npx/global install auditing the harness checkout itself compares two
+  // different paths and wrongly advises a repair that self-heal then skips
+  // (issue #40). Required lazily so a missing lib can never break session start.
+  const { isHarnessRepo } = require('../../scripts/lib/workspace');
+  const auditingSelf = isHarnessRepo(workspaceRoot)
+    || path.resolve(workspaceRoot) === path.resolve(__dirname, '..', '..');
+
+  if (missing.length > 0 && !auditingSelf) {
+    console.log(`\n[Self-Heal] Missing integration touchpoints: ${missing.join(', ')}`);
+    console.log(`[Self-Heal] Repair (idempotent): node "${path.join(__dirname, 'self-heal.js')}"`);
+  }
+} catch (err) {
+  // Audit is best-effort; never block session start.
+}
+
+// Check for handoff/state checkpoint from previous session
+const handoffFile = path.join(harnessDir, 'handoff-state.json');
+if (fs.existsSync(handoffFile)) {
+  try {
+    const handoff = JSON.parse(fs.readFileSync(handoffFile, 'utf8'));
+    if (handoff.status === 'failed') {
+      const exitStr = handoff.exitCode ? ` (exit code ${handoff.exitCode})` : '';
+      const border = "─".repeat(60);
+      console.log(`\n┌${border}┐`);
+      console.log(`│             Harness OS - Handoff Checkpoint              │`);
+      console.log(`├${border}┤`);
+      console.log(`│ - Last active action failed${exitStr.padEnd(30)} │`);
+      console.log(`│ - Action: ${String(handoff.tool || 'unknown').padEnd(46)} │`);
+      console.log(`│ - Last error output snippet:                             │`);
+      
+      const snippet = handoff.errorSummary || 'No snippet available';
+      const lines = snippet.split('\n').map(l => l.trim()).filter(Boolean).slice(-3);
+      if (lines.length > 0) {
+        lines.forEach(line => {
+          const paddedLine = line.slice(0, 54).padEnd(54);
+          console.log(`│     > ${paddedLine} │`);
+        });
+      } else {
+        console.log(`│     > None                                               │`);
+      }
+      console.log(`├${border}┤`);
+      console.log(`│ Hint: Use this context to continue resolving the issue   │`);
+      console.log(`│       efficiently or start on a new path.                │`);
+      console.log(`└${border}┘\n`);
+    }
+  } catch (err) {
+    // Ignore malformed files
+  }
+}
+
+console.log("Harness OS initialized. Ready for user prompt.");

package/plugins/harness-everything/skills/harness-everything/scripts/ensemble-policy.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const ENSEMBLE_MAX_CANDIDATES = 3;
+
+function unique(values) {
+  return [...new Set((values || []).filter(Boolean))];
+}
+
+function detectEnsembleTaskSignals(prompt) {
+  const text = String(prompt || '');
+  const comparableOutput = /\b(?:choice|choose|decision|decide|ranking|rank|ranked|verdict|recommendation|recommend|compare alternatives?|compare approaches?|which (?:option|approach|design)|select between|trade[- ]offs?)\b/i.test(text) ||
+    /(?:選擇|決策|排名|判定|建議|比較方案|比較方法|取捨)/.test(text);
+  const explicitDisagreement = /\b(?:disagreement|dissent|minority (?:view|position)|competing (?:answers|positions|approaches)|preserve disagreement)\b/i.test(text) ||
+    /(?:分歧|不同意見|少數意見|競爭方案)/.test(text);
+  const creativeGeneration = /\b(?:creative|brainstorm|story|poem|fiction|slogan|tagline|copywriting|marketing copy|logo|illustration|artwork|lyrics?|name ideas?|generate ideas?)\b/i.test(text) ||
+    /(?:創意|腦力激盪|故事|詩|標語|文案|插畫|歌詞|命名)/.test(text);
+  const mechanicalWork = /\b(?:mechanical|bulk rename|mass rename|rename all|replace all|reformat|format all|lint[- ]fix|sort imports?|codemod|repetitive edits?|generated files?|migrate all identifiers?)\b/i.test(text) ||
+    /(?:機械式|批次重新命名|全部取代|大量重複修改|格式化全部)/.test(text);
+  const highStakes = /\b(?:high[- ]stakes|safety[- ]critical|security[- ]critical|critical decision|material risk)\b/i.test(text) ||
+    /(?:高風險|高利害|關鍵決策)/.test(text);
+  return {
+    comparableOutput,
+    explicitDisagreement,
+    creativeGeneration,
+    mechanicalWork,
+    highStakes,
+  };
+}
+
+function applyEnsemblePolicy(contract, prompt) {
+  if (!contract || typeof contract !== 'object' || !contract.workflowPlan || !contract.taskShape) return contract;
+  const plan = contract.workflowPlan;
+  const shape = contract.taskShape;
+  const explicit = shape.explicitRequest || {};
+  const prohibitions = Array.isArray(explicit.prohibitions) ? explicit.prohibitions : [];
+  const signals = detectEnsembleTaskSignals(prompt);
+  const highUncertainty = shape.uncertainty === 'high';
+  const fableTopology = typeof plan.strategy === 'string' && plan.strategy.startsWith('fable-');
+  const comparable = signals.comparableOutput || signals.explicitDisagreement;
+
+  const reasonCodes = [];
+  if (highUncertainty) reasonCodes.push('high-uncertainty');
+  if (signals.highStakes) reasonCodes.push('high-stakes');
+  if (signals.comparableOutput) reasonCodes.push('comparable-output');
+  if (signals.explicitDisagreement) reasonCodes.push('explicit-disagreement');
+
+  let selected = (highUncertainty || signals.highStakes) && comparable && fableTopology;
+  if (signals.creativeGeneration) {
+    selected = false;
+    reasonCodes.push('ensemble-excluded-creative-generation');
+  }
+  if (signals.mechanicalWork) {
+    selected = false;
+    reasonCodes.push('ensemble-excluded-mechanical-work');
+  }
+  if (prohibitions.includes('ensemble')) {
+    selected = false;
+    reasonCodes.push('user-prohibited-ensemble');
+  }
+  if (shape.hostCapabilities && shape.hostCapabilities.subagents === 'unavailable') {
+    selected = false;
+    reasonCodes.push('ensemble-subagents-unavailable');
+  }
+  if (plan.fallback && plan.fallback.disposition === 'blocked') {
+    selected = false;
+    reasonCodes.push('ensemble-base-plan-blocked');
+  }
+
+  plan.reasonCodes = unique([...(plan.reasonCodes || []), ...reasonCodes]);
+  if (!selected) {
+    plan.ensemble = null;
+    return contract;
+  }
+
+  const selectionReason = signals.explicitDisagreement
+    ? 'ensemble-disagreement-deliverable'
+    : signals.highStakes
+      ? 'ensemble-high-stakes-comparable-output'
+      : 'ensemble-high-uncertainty-comparable-output';
+
+  plan.ensemble = {
+    maxCandidates: ENSEMBLE_MAX_CANDIDATES,
+    diversity: ['model', 'prompt', 'evidence'],
+    synthesis: 'preserve-disagreement',
+    verifier: 'independent',
+    reasonCodes: unique([selectionReason, ...reasonCodes]),
+  };
+  plan.patterns = unique([...(plan.patterns || []), 'parallel-self-consistency']);
+  plan.requiredInvariants = unique([
+    ...(plan.requiredInvariants || []),
+    'preserve-disagreement',
+    'independent-ensemble-verifier',
+  ]);
+  plan.reasonCodes = unique([...(plan.reasonCodes || []), 'ensemble-review-selected']);
+  return contract;
+}
+
+module.exports = {
+  ENSEMBLE_MAX_CANDIDATES,
+  applyEnsemblePolicy,
+  detectEnsembleTaskSignals,
+};

package/plugins/harness-everything/skills/harness-everything/scripts/kernel-router.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  createDegradedRouterContract,
+  validateRouterContract,
+} = require('./router-contract');
+const { applyEnsemblePolicy } = require('./ensemble-policy');
+
+/**
+ * Harness Kernel Router
+ *
+ * tier-router remains the human-readable classifier/guide detector. The
+ * kernel consumes its versioned side-channel JSON contract instead of
+ * scraping human-readable stdout. Phase 2 selects an execution topology, but
+ * the router still only emits a plan: executors retain responsibility for
+ * spawning agents, creating workspaces, running tools, and enforcing gates.
+ * Phase 4 attaches ensemble-review only as a post-selection modifier.
+ */
+
+const INVARIANT_TEXT = {
+  'scope-lock': 'Route before execution: stay inside the authorized task/repository scope.',
+  'verify-before-claim': 'Verify before claim: completion claims require objective evidence appropriate to the change.',
+  'replan-after-repeated-failure': 'Re-plan on repetition: after 3 same-signature failures, stop micro-retrying and zoom out/re-diagnose.',
+  'loop-budget': 'Stop iterative-single when its explicit iteration budget is exhausted.',
+  'objective-verification': 'Use an objective check for iterative work; self-critique alone is not verification.',
+  'stage-contracts': 'Fable stages must have explicit stage contracts and pass conditions.',
+  'cold-verification': 'Fable delivery requires a cold/independent verifier where specified.',
+  'parallel-scope-contract': 'Parallel work requires declared independent scopes and non-overlapping/read-only writes.',
+  'synthesis-barrier': 'Do not claim parallel completion until all workstreams reach the synthesis barrier.',
+  'handoff-contracts': 'Multi-agent workspace work uses orchestrator-owned handoff contracts; workers do not form a peer mesh.',
+  'workspace-state': 'Durable workspace state remains scoped to the workspace and existing state conventions.',
+  'pre-action-approval': 'Irreversible/external side effects require approval before the exact payload executes.',
+  'preserve-disagreement': 'Ensemble synthesis must retain unresolved minority positions and evidence gaps.',
+  'independent-ensemble-verifier': 'Ensemble delivery requires a verifier independent from the candidate identities; agreement alone is not proof.',
+};
+
+const SKILL_TEXT = {
+  'tdd': 'tdd: useful for behavioral changes where executable tests can drive the implementation.',
+  'verification-loop': 'verification-loop: useful for systematic build/lint/test/diff evidence before delivery.',
+  'fable-mode': 'fable-mode / fable-discipline: useful for macro planning or deliberate multi-agent decomposition.',
+  'fable-discipline': null,
+  'multi-agent-workspace': 'multi-agent-workspace: useful when durable bounded delegation, handoffs, or workspace memory are required.',
+};
+
+function sanitizeClassifierOutput(stdout) {
+  const lines = String(stdout || '').split(/\r?\n/);
+  const filtered = [];
+  let skipLegacyContinuation = false;
+
+  for (const line of lines) {
+    if (line.includes('=> BASE EXECUTION LOOP:')) {
+      skipLegacyContinuation = true;
+      continue;
+    }
+    if (skipLegacyContinuation && line.includes('Track exactly ONE item in-progress')) {
+      skipLegacyContinuation = false;
+      continue;
+    }
+    skipLegacyContinuation = false;
+    filtered.push(line);
+  }
+
+  return filtered.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function readStructuredContract(contractPath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+    const validation = validateRouterContract(parsed);
+    if (!validation.valid) {
+      return createDegradedRouterContract(
+        'router-contract-invalid',
+        `Structured router contract failed validation: ${validation.errors.join('; ')}`,
+      );
+    }
+    return parsed;
+  } catch (err) {
+    return createDegradedRouterContract(
+      'router-contract-unavailable',
+      `Structured router contract unavailable: ${err.message}`,
+    );
+  }
+}
+
+function resolvePrompt(prompt, stdinPayload) {
+  if (prompt) return prompt;
+  if (!stdinPayload) return '';
+  try {
+    const payload = JSON.parse(stdinPayload);
+    return typeof payload.prompt === 'string' ? payload.prompt : '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function printWorkflowPlan(plan) {
+  const visible = {
+    schemaVersion: plan.schemaVersion,
+    routingStatus: plan.routingStatus,
+    tier: plan.tier,
+    strategy: plan.strategy,
+    strategySelection: plan.strategySelection,
+    actionGate: plan.actionGate,
+    limits: plan.limits,
+    parallelism: plan.parallelism,
+    workspace: plan.workspace,
+    memory: plan.memory,
+    verification: plan.verification,
+    ensemble: plan.ensemble,
+    fallback: plan.fallback,
+    reasonCodes: plan.reasonCodes,
+  };
+  console.log(`\n=> ROUTER WORKFLOW PLAN (JSON): ${JSON.stringify(visible)}`);
+}
+
+function printKernelContract(plan) {
+  console.log('\n=> REQUIRED HARNESS INVARIANTS:');
+  for (const invariant of plan.requiredInvariants || []) {
+    console.log(`   - ${invariant}: ${INVARIANT_TEXT[invariant] || 'Required by the selected workflow plan.'}`);
+  }
+
+  console.log('\n=> SUGGESTED SKILLS (ADVISORY — no fixed workflow order):');
+  if (Array.isArray(plan.suggestedSkills) && plan.suggestedSkills.length > 0) {
+    const emitted = new Set();
+    for (const skill of plan.suggestedSkills) {
+      if (emitted.has(skill)) continue;
+      const text = Object.prototype.hasOwnProperty.call(SKILL_TEXT, skill) ? SKILL_TEXT[skill] : `${skill}: advisory for the selected topology.`;
+      if (text) console.log(`   - ${text}`);
+      emitted.add(skill);
+      if (skill === 'fable-mode') emitted.add('fable-discipline');
+    }
+    if (plan.strategy && plan.strategy.startsWith('fable-')) {
+      console.log('   - Use these selectively; Tier 3/Fable does not create a universal skill pipeline.');
+    }
+  } else if (plan.strategy === 'direct-single') {
+    console.log('   - No mandatory domain skill. Prefer the bounded direct path and load a focused skill only when it adds value.');
+  } else if (plan.strategySelection === 'deferred') {
+    console.log('   - Strategy is deferred/unclassified. Do not infer triviality; choose the smallest justified approach from task evidence.');
+  } else {
+    console.log('   - No additional skill suggestion from the workflow plan.');
+  }
+
+  if (plan.ensemble) {
+    console.log(`\n=> ENSEMBLE REVIEW: bounded to ${plan.ensemble.maxCandidates} candidates; synthesis=${plan.ensemble.synthesis}; verifier=${plan.ensemble.verifier}. Preserve minority positions and do not claim improvement without paired evidence.`);
+  }
+
+  if (plan.actionGate && plan.actionGate.required) {
+    console.log(`\n=> ACTION GATE REQUIRED: ${plan.actionGate.reasonCodes.join(', ')}; disposition=${plan.actionGate.disposition}. The router only declares this requirement; execution must not bypass approval.`);
+  }
+
+  if (plan.fallback && plan.fallback.disposition !== 'none') {
+    console.log(`\n=> ROUTING FALLBACK: ${plan.fallback.disposition}/${plan.fallback.mode}; ${plan.fallback.reasonCodes.join(', ')}.`);
+  }
+
+  if (plan.routingStatus === 'degraded') {
+    console.log('\n=> ROUTING DEGRADATION: Structured routing is degraded. Keep the strategy deferred unless independent evidence supports a route; do not silently downgrade to Tier 1/direct execution.');
+  }
+
+  console.log('\n=> ORCHESTRATION POLICY: Do not enforce workflow order. Enforce workflow invariants from the plan; suggested skills remain advisory. The router plans; execution components execute.');
+}
+
+function run(prompt, stdinPayload) {
+  const classifierPath = path.join(__dirname, 'tier-router.js');
+  const contractPath = path.join(os.tmpdir(), `harness-router-${process.pid}-${crypto.randomUUID()}.json`);
+  const args = prompt ? [classifierPath, prompt] : [classifierPath];
+  const result = spawnSync(process.execPath, args, {
+    input: prompt ? undefined : stdinPayload,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HARNESS_ROUTER_CONTRACT_PATH: contractPath,
+    },
+  });
+
+  if (result.error) {
+    console.error(`[Harness Kernel] Failed to execute tier-router.js: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  const sanitized = sanitizeClassifierOutput(result.stdout);
+  if (sanitized) console.log(sanitized);
+  if (result.stderr) process.stderr.write(result.stderr);
+
+  const contract = readStructuredContract(contractPath);
+  applyEnsemblePolicy(contract, resolvePrompt(prompt, stdinPayload));
+  try {
+    fs.rmSync(contractPath, { force: true });
+  } catch (err) {
+    // Temporary contract cleanup is best effort only.
+  }
+
+  printWorkflowPlan(contract.workflowPlan);
+  printKernelContract(contract.workflowPlan);
+
+  if (result.status !== 0) process.exit(result.status === null ? 1 : result.status);
+}
+
+const prompt = process.argv.slice(2).join(' ');
+if (prompt) {
+  run(prompt, null);
+} else if (process.stdin.isTTY) {
+  run('', null);
+} else {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => run('', input));
+}