opencode-harness-kit 0.0.0-stage → 0.1.0

package/agents/plan.md

@@ -0,0 +1,61 @@
+---
+description: Plans work before code exists. Use when a task is vague, spans more than a few files, or two people could disagree about what "done" means.
+mode: primary
+model: opencode/space-bunny-free
+variant: max
+steps: 25
+permission:
+  edit: deny
+  bash:
+    "*": deny
+    "git status *": allow
+    "git log *": allow
+    "git diff *": allow
+    "git -C * status*": allow
+    "git -C * log*": allow
+    "git -C * diff*": allow
+    "grep*": allow
+    "rg*": allow
+    "find*": allow
+    "cat*": allow
+    "ls*": allow
+---
+
+You turn a request into a plan someone else can execute without asking you
+anything. You do not write the code.
+
+## What to produce
+
+1. **Goal** — one sentence, in the caller's words. If you cannot write it, the
+   request is not understood yet.
+2. **Constraints** — what must not change, what must not be touched.
+3. **Tasks** — each one small enough to finish in a few minutes, and each with:
+   - the exact file paths to change
+   - what the change is, concretely, not "handle errors"
+   - how to verify it: the exact command, and what passing looks like
+4. **Risks** — the things most likely to go wrong, and the cheapest way to find
+   out early.
+
+## Rules
+
+- Read before you plan, but read narrowly. Grep the file names and read the
+  actual functions with an offset. A plan built on assumed file paths is worse
+  than no plan, and reading a whole file to check one function wastes context
+  the build step will need.
+- No task may be "and then the rest". If it cannot be stated in one sentence
+  with a verify command, split it.
+- Order tasks so each one leaves the repository working. A plan whose middle
+  step leaves tests red is a plan nobody will finish.
+- If the request needs a decision you cannot make from the code and the
+  request, stop and ask **one** specific question, not five. Ask only when a
+  wrong guess costs real money, breaks the build irreparably, publishes
+  something, or is irreversible. Everything else is your call, and you make it.
+- If the request is too small to need a plan, say that in one line and name the
+  single edit instead.
+
+## Report
+
+Markdown. No preamble, no restating the request.
+
+See also the `space-plan` skill for the full plan → build → review → finish
+loop and the shared task-file contract.

package/agents/reviewer.md

@@ -0,0 +1,62 @@
+---
+description: Reviews work in two passes without editing. Use after a build step, before a commit or a release decision.
+mode: subagent
+model: opencode/space-bunny-free
+variant: max
+steps: 15
+permission:
+  edit: deny
+  bash:
+    "*": deny
+    "git diff *": allow
+    "git log *": allow
+    "git show*": allow
+    "git status *": allow
+    "git -C * diff*": allow
+    "git -C * log*": allow
+    "grep*": allow
+    "cat*": allow
+---
+
+You review. You never fix, because a reviewer who edits stops being a reviewer.
+
+## Pass 1, does it do what was asked
+
+Compare the diff against the task it came from. Ignore style entirely.
+
+- Every requirement in the task met? Name any that is not, with `file:line`.
+- Anything changed that the task did not ask for?
+- Does the verify command the task named actually exist, and does it pass?
+- Any file claimed as changed that is not in the diff?
+
+A failure here is a blocker. Report it and stop.
+
+## Pass 2, is it any good
+
+Only if pass 1 is clean.
+
+- Duplication that will bite on the next change
+- Error paths that swallow the reason
+- Edge cases the tests do not cover, named specifically
+- Names that lie about what they hold
+- Dead code, commented-out code, debug leftovers
+
+## Rules
+
+- Every finding needs `file:line` and a concrete failure it would cause. A
+  finding without a consequence is a preference, not a defect; label it as one
+  or drop it.
+- Severity is real: `blocker`, `should-fix`, `nit`. Do not inflate.
+- Do not propose a rewrite. Name the smallest change that removes the defect.
+- Read the diff, not the whole file. Do not go hunting for issues outside the
+  change you were asked about.
+- Silence is a valid result. If the diff is clean, say so plainly rather than
+  inventing something to report.
+
+## Report
+
+Two sections, pass 1 then pass 2. If pass 1 blocked, pass 2 does not run and
+you say why.
+
+See also the `space-review` skill for the full plan → build → review → finish
+loop and the shared task-file contract.

package/agents/verify.md

@@ -0,0 +1,54 @@
+---
+description: Runs the project's checks and reports results. Use before claiming a task is done.
+mode: subagent
+model: opencode/space-bunny-free
+variant: low
+steps: 20
+permission:
+  edit: deny
+  bash:
+    "*": ask
+    "git status *": allow
+    "git diff *": allow
+    "mkdir*": allow
+    "ps*": allow
+    "python3 -m pytest*": allow
+    "pytest*": allow
+    "ruff*": allow
+    "mypy*": allow
+    "black*": allow
+    "npm test*": allow
+    "npm run *": allow
+    "npx tsc*": allow
+    "cargo test*": allow
+    "go test*": allow
+---
+
+You run checks. You do not fix them.
+
+## Method
+
+1. Find the project's own check commands. Look in the README, `Makefile`,
+   `package.json` scripts, or CI config. Prefer what the project already uses
+   over anything you invent.
+2. Run them. Report what happened.
+3. If a check fails, read the failure and reduce it to a short list: the file,
+   the line, and the message. Do not fix it.
+
+## Rules
+
+- Paste real output. If you did not run it, say you did not run it.
+- One failing check is a failure. Do not report a subset as if it were the
+  whole suite.
+- Do not add, remove, or skip a test to make a suite pass. If a test looks
+  wrong, report that as a finding and leave it failing.
+- Exit code matters: a command that printed errors and exited 0 has not passed.
+- If a check cannot run, say why: missing dependency, no such script. That is a
+  finding too.
+- Truncated output is not a pass. If the runner cut the output off before the
+  summary line, say so rather than inferring success.
+
+## Report
+
+A table of command, exit code, and one line of the failure if any. Then the
+short failure list. Nothing else.

package/bin/baseline.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+// baseline.mjs - measure a real OpenCode install so pruning thresholds are
+// grounded in numbers instead of guesses.
+//
+//   node bin/baseline.mjs                       human-readable report
+//   node bin/baseline.mjs --json > out.json     machine-readable
+//   node bin/baseline.mjs --db /path/to.db      override the database
+//
+// Node 22 has no node:sqlite, so we shell out to the sqlite3 CLI in
+// read-only mode. Everything is aggregated in SQL, nothing is buffered twice.
+
+import { execFileSync } from "node:child_process"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+const args = process.argv.slice(2)
+const wantJson = args.includes("--json")
+const dbArg = args.indexOf("--db")
+const DB = dbArg >= 0 ? args[dbArg + 1] : join(homedir(), ".local/share/opencode/opencode.db")
+
+if (!existsSync(DB)) {
+  console.error(`opencode database not found: ${DB}`)
+  console.error("pass --db <path> or run opencode at least once first")
+  process.exit(1)
+}
+
+function query(sql) {
+  const out = execFileSync("sqlite3", ["-json", `file:${DB}?mode=ro`, sql], {
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024,
+  }).trim()
+  return out ? JSON.parse(out) : []
+}
+
+const ASSISTANT = `json_extract(data,'$.role')='assistant'`
+
+// Approximate percentile via row_number: pick the value at rank p*total.
+function percentile(expr, p) {
+  const rows = query(
+    `select v from (
+       select ${expr} as v, row_number() over (order by ${expr}) as rn,
+              count(*) over () as total
+       from message where ${ASSISTANT} and ${expr} is not null
+     ) where rn = cast(max(cast(total * ${p} as integer), 1) as integer)`,
+  )
+  return rows[0]?.v ?? null
+}
+
+// NOTE: SQLite's OR is strictly logical and yields 0/1, not the first truthy
+// operand like MySQL. `sum(x or 0)` therefore sums booleans. Use coalesce.
+const IN = "coalesce(json_extract(data,'$.tokens.input'), 0)"
+const CREAD = "coalesce(json_extract(data,'$.tokens.cache.read'), 0)"
+const CTX = `(${IN} + ${CREAD})`
+const OUT = "coalesce(json_extract(data,'$.tokens.output'), 0)"
+const REA = "coalesce(json_extract(data,'$.tokens.reasoning'), 0)"
+
+const totals = query(
+  `select
+     (select count(*) from session)                                   as sessions,
+     (select count(distinct date(time_created/1000,'unixepoch','localtime')) from session) as days,
+     count(*)                                                        as messages,
+     sum(${IN})   as input, sum(${OUT}) as output,
+     sum(${REA})  as reasoning, sum(${CREAD}) as cache_read,
+     (select count(*) from session where time_compacting is not null) as compacted,
+     (select coalesce(sum(cost),0) from session)                      as cost
+   from message where ${ASSISTANT}`,
+)[0]
+
+const ctx = {
+  p50: percentile(CTX, 0.5),
+  p90: percentile(CTX, 0.9),
+  p99: percentile(CTX, 0.99),
+  max: query(`select max(${CTX}) as v from message where ${ASSISTANT}`)[0]?.v ?? 0,
+}
+
+const freshInputP50 = percentile(IN, 0.5)
+
+const finish = query(
+  `select coalesce(json_extract(data,'$.finish'),'(none)') as finish, count(*) as n
+   from message where ${ASSISTANT} group by 1 order by n desc`,
+)
+
+const byModel = query(
+  `select json_extract(data,'$.providerID') || '/' || json_extract(data,'$.modelID') as model,
+          coalesce(json_extract(data,'$.variant'),'(default)') as variant,
+          count(*) as messages,
+          sum(${OUT}) as output, sum(${REA}) as reasoning,
+          sum(${CREAD}) as cache_read, sum(${IN}) as input
+   from message where ${ASSISTANT}
+   group by model, variant order by cache_read desc`,
+)
+
+// Median seconds per assistant request, per model+variant. Effort tiering only
+// pays off if max is actually slower than the tiers below it.
+const DURATION =
+  "(json_extract(data,'$.time.completed') - json_extract(data,'$.time.created')) / 1000.0"
+const MODEL_ID = "json_extract(data,'$.providerID') || '/' || json_extract(data,'$.modelID')"
+const VARIANT = "coalesce(json_extract(data,'$.variant'),'(default)')"
+// Median via row_number. SQLite's `/` on integers truncates, so `total/2`
+// picks rank floor(n/2): undershooting for odd n (n=5 gave rank 2 instead of
+// 3) and returning the lower middle rank instead of the average for even n.
+// The (total+1)/2 rank is the true median for odd n; even n averages ranks
+// n/2 and n/2+1.
+const medianLatency = query(
+  `select model, variant, printf('%.1f', avg(ms)) as median_ms from (
+     select model, variant, ms, rn, total from (
+       select model, variant, ms,
+              row_number() over (partition by model, variant order by ms) as rn,
+              count(*) over (partition by model, variant) as total
+       from (select ${MODEL_ID} as model, ${VARIANT} as variant, ${DURATION} as ms
+             from message
+             where ${ASSISTANT} and ${DURATION} is not null and ${DURATION} > 0)
+     )
+   ) where rn = cast((total + 1) / 2 as integer)
+       or (total % 2 = 0 and rn = cast((total + 2) / 2 as integer))
+   group by model, variant`,
+)
+
+// Share of stored message bytes by part type - the reason context bloats.
+const partBytes = query(
+  `select json_extract(data,'$.type') as type, count(*) as n, sum(length(data)) as bytes
+   from part group by 1 order by bytes desc`,
+)
+const partTotal = partBytes.reduce((a, r) => a + (r.bytes ?? 0), 0) || 1
+
+// Permission pressure: how many historical bash commands would prompt.
+const BASH = `json_extract(data,'$.type')='tool' and json_extract(data,'$.tool')='bash'`
+const bashRows = query(
+  `select json_extract(data,'$.state.input.command') as cmd from part where ${BASH}`,
+)
+const cmds = bashRows.map((r) => (r.cmd ?? "").trim()).filter(Boolean)
+
+// Approximation of opencode's permission glob: `X *` means "X " followed by
+// anything, so it does NOT match a bare `X`; the `X*` form covers both.
+// [\s\S] rather than . because stored commands often embed newlines
+// (heredocs, python3 -c "..."), and `.` does not cross a newline.
+function glob(cmd, pat) {
+  const re = new RegExp(
+    "^" +
+      pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[\\s\\S]*") +
+      "$",
+  )
+  return re.test(cmd)
+}
+const allowed = (c) => kitAllowlist.some((p) => glob(c, p))
+const topAskers = () => {
+  const heads = new Map()
+  for (const c of cmds) {
+    if (allowed(c)) continue
+    const p = c.split(/\s+/)
+    let h = p[0] ?? "?"
+    if (["git", "npm", "bun", "uv", "ssh", "curl", "python3", "npx"].includes(h) && p[1]) {
+      h += " " + p[1]
+    }
+    heads.set(h, (heads.get(h) ?? 0) + 1)
+  }
+  return [...heads.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20)
+    .map(([head, count]) => ({ head, count }))
+}
+
+// Imported, not copied. This file used to keep its own transcription of the
+// allowlist, which meant the number it reported was whatever the list looked
+// like when the copy was last edited. Every tuning decision in this project is
+// supposed to rest on this measurement, so it has to measure the real list.
+const { BASH_ALLOWLIST } = await import(new URL("../src/config.js", import.meta.url))
+const kitAllowlist = BASH_ALLOWLIST
+const currentAllow = [
+  "git status *", "git log *", "git diff *", "grep *",
+  "python3 src/main.py *", "python3 -m pytest *",
+]
+const wouldAskNow = cmds.filter((c) => !currentAllow.some((p) => glob(c, p))).length
+const wouldAskKit = cmds.filter((c) => !allowed(c)).length
+
+// Cost if the same work had run on a paid route (reference rates, per 1M).
+const RATE = { input: 0.15, output: 0.6, cacheRead: 0.03 }
+const paidEquivalent =
+  ((totals.input ?? 0) / 1e6) * RATE.input +
+  ((totals.output + (totals.reasoning ?? 0)) / 1e6) * RATE.output +
+  ((totals.cache_read ?? 0) / 1e6) * RATE.cacheRead
+
+// Truncation pressure: how many tool results were cut by `tool_output`, and how
+// much of that turned into an extra round trip.
+//
+// This exists because the kit once shipped max_lines 200 / max_bytes 8192 on
+// the reasoning that tight truncation "saves context", and a later install
+// measured 415 of 2,959 reads exceeding 8 KB against 418 reads issued with an
+// `offset`. Truncation causes the re-read roughly one for one, and at the
+// measured ~17s median per request that round trip is more expensive than the
+// tokens it saves. Re-run this before changing these numbers again.
+const TOOL = `json_extract(data,'$.type')='tool'`
+const readTruncation = query(
+  `select
+     count(*)                                                              as reads,
+     sum(case when length(coalesce(json_extract(data,'$.state.output'),'')) >  8192 then 1 else 0 end) as over_8k,
+     sum(case when length(coalesce(json_extract(data,'$.state.output'),'')) > 24576 then 1 else 0 end) as over_24k,
+     sum(case when length(coalesce(json_extract(data,'$.state.output'),'')) > 51200 then 1 else 0 end) as over_50k,
+     sum(case when json_extract(data,'$.state.metadata.display.totalLines') is not null
+              and json_extract(data,'$.state.metadata.display.lineEnd')
+                  < json_extract(data,'$.state.metadata.display.totalLines')
+          then 1 else 0 end)                                               as line_cut,
+     sum(case when json_extract(data,'$.state.input.offset') is not null then 1 else 0 end) as reread
+   from part where ${TOOL} and json_extract(data,'$.tool')='read'`,
+)[0]
+
+// Structured questions actually asked. A few is healthy; a stream of them means
+// the agent is asking instead of deciding, which is what GLOBAL.md's decision
+// rule exists to stop.
+const questionStats = query(
+  `select count(*) as asked from part where ${TOOL} and json_extract(data,'$.tool')='question'`,
+)[0]?.asked ?? 0
+
+// Search-before-read discipline. The paper in docs/KNOWN-LIMITS.md found no
+// production harness using embedding retrieval: all of them search first. A
+// read:grep ratio in the hundreds means the agent is loading whole files to
+// find out where something lives, which is the most expensive habit measured
+// anywhere in this kit.
+const toolCounts = query(
+  `select json_extract(data,'$.tool') as tool, count(*) as n from part where ${TOOL} group by 1`,
+)
+const toolByName = Object.fromEntries(toolCounts.map((r) => [r.tool, r.n]))
+const searches = (toolByName.grep ?? 0) + (toolByName.glob ?? 0) + (toolByName.list ?? 0)
+const reads = toolByName.read ?? 0
+
+const report = {
+  database: DB,
+  generated: new Date().toISOString(),
+  volume: {
+    sessions: totals.sessions,
+    days: totals.days,
+    assistantMessages: totals.messages,
+    compactionEvents: totals.compacted,
+  },
+  tokens: {
+    input: totals.input ?? 0,
+    output: totals.output ?? 0,
+    reasoning: totals.reasoning ?? 0,
+    cacheRead: totals.cache_read ?? 0,
+    cacheToInputRatio: totals.input ? +((totals.cache_read ?? 0) / totals.input).toFixed(1) : null,
+  },
+  contextPerRequest: { ...ctx, freshInputP50: freshInputP50 },
+  contextBuckets: [
+    [0, 10_000], [10_000, 50_000], [50_000, 100_000],
+    [100_000, 200_000], [200_000, 400_000], [400_000, Number.MAX_SAFE_INTEGER],
+  ].map(([lo, hi]) => ({
+    range: hi >= Number.MAX_SAFE_INTEGER ? `${lo}+` : `${lo}-${hi}`,
+    count: query(
+      `select count(*) as n from message where ${ASSISTANT} and ${CTX} >= ${lo} and ${CTX} < ${hi}`,
+    )[0].n,
+  })),
+  storedBytesByType: partBytes.map((r) => ({
+    type: r.type,
+    count: r.n,
+    megabytes: +((r.bytes ?? 0) / 1e6).toFixed(2),
+    share: +(((r.bytes ?? 0) / partTotal) * 100).toFixed(1),
+  })),
+  finishReasons: finish,
+  readPressure: {
+    reads,
+    searches,
+    readPerSearch: searches ? +((reads / searches)).toFixed(1) : null,
+    overBytes: { "8k": readTruncation.over_8k ?? 0, "24k": readTruncation.over_24k ?? 0, "50k": readTruncation.over_50k ?? 0 },
+    cutByLineCap: readTruncation.line_cut ?? 0,
+    rereadWithOffset: readTruncation.reread ?? 0,
+  },
+  questionPressure: { asked: questionStats },
+  byModel: byModel.map((r) => {
+    const lat = medianLatency.find((l) => l.model === r.model && l.variant === r.variant)
+    return {
+      model: r.model,
+      variant: r.variant,
+      messages: r.messages,
+      reasoningShare:
+        r.output + r.reasoning > 0
+          ? +((r.reasoning / (r.output + r.reasoning)) * 100).toFixed(1)
+          : 0,
+      cacheRead: r.cache_read,
+      medianSeconds: lat ? Number(lat.median_ms) : null,
+    }
+  }),
+  permissionPressure: {
+    bashCommands: cmds.length,
+    wouldAskWithCurrentAllowlist: wouldAskNow,
+    wouldAskWithKitAllowlist: wouldAskKit,
+    currentPromptShare: cmds.length ? +((wouldAskNow / cmds.length) * 100).toFixed(1) : 0,
+    kitPromptShare: cmds.length ? +((wouldAskKit / cmds.length) * 100).toFixed(1) : 0,
+    topRemainingAskers: topAskers(),
+  },
+  cost: {
+    recorded: +(totals.cost ?? 0).toFixed(2),
+    paidRouteEquivalent: +paidEquivalent.toFixed(2),
+    ratePerMillion: RATE,
+  },
+}
+
+if (wantJson) {
+  console.log(JSON.stringify(report, null, 2))
+  process.exit(0)
+}
+
+const n = (x) => (x ?? 0).toLocaleString("en-US")
+const m = (x) => `${((x ?? 0) / 1e6).toFixed(2)}M`
+const pct = (a, b) => (b ? `${((a / b) * 100).toFixed(1)}%` : "-")
+
+const line = (k, v) => console.log(`  ${k.padEnd(26)} ${v}`)
+
+console.log(`\nopencode baseline  ·  ${DB}`)
+console.log(`generated ${report.generated}\n`)
+
+console.log("VOLUME")
+line("sessions", n(report.volume.sessions))
+line("days", n(report.volume.days))
+line("assistant messages", n(report.volume.assistantMessages))
+line("compaction events", `${n(report.volume.compactionEvents)}  ${report.volume.compactionEvents === 0 ? "(never fired)" : ""}`)
+
+console.log("\nTOKENS")
+line("input", m(report.tokens.input))
+line("output", m(report.tokens.output))
+line("reasoning", m(report.tokens.reasoning))
+line("cache read", `${m(report.tokens.cacheRead)}  (${report.tokens.cacheToInputRatio}x input)`)
+
+console.log("\nCONTEXT PER REQUEST")
+line("p50", n(report.contextPerRequest.p50))
+line("p90", n(report.contextPerRequest.p90))
+line("p99", n(report.contextPerRequest.p99))
+line("max", n(report.contextPerRequest.max))
+line("fresh input p50", n(report.contextPerRequest.freshInputP50))
+for (const b of report.contextBuckets) line(`  ${b.range}`, n(b.count))
+
+console.log("\nSTORED MESSAGE BYTES")
+for (const b of report.storedBytesByType) {
+  line(b.type, `${String(b.megabytes).padStart(7)} MB  ${String(b.share).padStart(5)}%  (${n(b.count)} parts)`)
+}
+
+console.log("\nREAD PRESSURE")
+line("read calls", n(report.readPressure.reads))
+line("grep/glob/list", n(report.readPressure.searches))
+line("reads per search", `${report.readPressure.readPerSearch ?? "-"}  (whole-file reads to find code)`)
+line("reads over 8 KB", n(report.readPressure.overBytes["8k"]))
+line("reads over 24 KB", n(report.readPressure.overBytes["24k"]))
+line("reads over 50 KB", n(report.readPressure.overBytes["50k"]))
+line("cut by the 200-line cap", n(report.readPressure.cutByLineCap))
+line("re-reads with an offset", `${n(report.readPressure.rereadWithOffset)}  (this is the cost the line cap created)`)
+
+console.log("\nQUESTIONS ASKED")
+line("question tool calls", n(report.questionPressure.asked))
+
+console.log("\nBY MODEL")
+for (const r of report.byModel) {
+  const lat = r.medianSeconds != null ? ` · ${r.medianSeconds}s median` : ""
+  line(`${r.model} ${r.variant}`,
+    `${n(r.messages)} msgs · reasoning ${r.reasoningShare}% · cache ${m(r.cacheRead)}${lat}`)
+}
+
+console.log("\nPERMISSION PRESSURE (historical bash commands)")
+line("bash commands", n(report.permissionPressure.bashCommands))
+line("prompt with current list", `${n(report.permissionPressure.wouldAskWithCurrentAllowlist)} (${report.permissionPressure.currentPromptShare}%)`)
+line("prompt with kit allowlist", `${n(report.permissionPressure.wouldAskWithKitAllowlist)} (${report.permissionPressure.kitPromptShare}%)`)
+console.log("\n  still prompts with kit allowlist (tune from here):")
+for (const t of report.permissionPressure.topRemainingAskers) {
+  line(`    ${t.head}`, n(t.count))
+}
+
+console.log("\nCOST")
+line("recorded", `$${report.cost.recorded}`)
+line("same work, paid route", `$${report.cost.paidRouteEquivalent}  @ $${RATE.input}/$${RATE.output}/$${RATE.cacheRead} per 1M`)
+console.log()

package/bin/git-hooks/pre-commit

@@ -0,0 +1,30 @@
+#!/bin/sh
+# Installed by `oc-harness install`. Remove with: rm .git/hooks/pre-commit
+#
+# Runs the offline gate on every commit. The live-install half is deliberately
+# left out: measure and attribute read ~/.local/share/opencode, which is slow,
+# machine-specific, and irrelevant to whether a commit broke the kit.
+#
+# On a machine that has never run OpenCode, test:install cannot run at all, so
+# this hook uses the subset that needs nothing but the repository.
+
+set -e
+
+repo_root=$(git rev-parse --show-toplevel)
+cd "$repo_root"
+
+if [ -n "$SKIP_SPACE_HARNESS_HOOK" ]; then
+  echo "pre-commit: skipped (SKIP_SPACE_HARNESS_HOOK set)"
+  exit 0
+fi
+
+echo "pre-commit: npm run test:all"
+if ! npm run test:all >/tmp/space-harness-hook.log 2>&1; then
+  echo "pre-commit: FAILED. Last lines:"
+  tail -30 /tmp/space-harness-hook.log
+  echo ""
+  echo "Fix it, or commit with --no-verify if you are certain it is not yours."
+  exit 1
+fi
+
+exit 0