@outerlayer/cli 0.2.0 → 0.4.1

package/dist/chunk-WFJ65NUD.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { ArtifactTombstoneRecordSchema, ArtifactSpoolRecordSchema } from './chunk-4C4THABW.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { mkdirSync, appendFileSync, writeFileSync, renameSync, existsSync, unlinkSync, readdirSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+function artifactsSpoolPath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool", "artifacts.jsonl");
+}
+function artifactBlobsDir(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool", "artifact-blobs");
+}
+function artifactsStatePath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool", "artifacts.state.json");
+}
+var ARTIFACT_RETRY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function appendArtifactRecord(record, home = homeFromEnv()) {
+  const path = artifactsSpoolPath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, JSON.stringify(record) + "\n");
+}
+function appendArtifactTombstone(artifactId, home = homeFromEnv(), now = () => /* @__PURE__ */ new Date()) {
+  const path = artifactsSpoolPath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  const record = { rec: "artifact-tombstone", artifactId, t: now().toISOString() };
+  appendFileSync(path, JSON.stringify(record) + "\n");
+}
+function walkArtifactSpoolLines(home, visit) {
+  let buf;
+  try {
+    buf = readFileSync(artifactsSpoolPath(home));
+  } catch {
+    return;
+  }
+  let pos = 0;
+  while (pos < buf.length) {
+    const nl = buf.indexOf(10, pos);
+    const textEnd = nl === -1 ? buf.length : nl;
+    const text = buf.subarray(pos, textEnd).toString("utf8").trim();
+    if (text) visit(text, pos);
+    if (nl === -1) break;
+    pos = nl + 1;
+  }
+}
+function isArtifactTombstoned(artifactId, home = homeFromEnv()) {
+  let found = false;
+  walkArtifactSpoolLines(home, (text) => {
+    if (found) return;
+    try {
+      const parsed = ArtifactTombstoneRecordSchema.safeParse(JSON.parse(text));
+      if (parsed.success && parsed.data.artifactId === artifactId) found = true;
+    } catch {
+    }
+  });
+  return found;
+}
+var KNOWN_SPOOL_RECORD_TYPES = /* @__PURE__ */ new Set(["artifact", "artifact-tombstone"]);
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var MAX_DISPLAYED_REC_TYPE_LENGTH = 100;
+var CONTROL_CHAR_PATTERN = new RegExp(
+  `[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}]`,
+  "g"
+);
+function sanitizeTerminal(text) {
+  return text.replace(CONTROL_CHAR_PATTERN, "");
+}
+function sanitizeRecType(rec) {
+  const stripped = sanitizeTerminal(rec);
+  return stripped.length > MAX_DISPLAYED_REC_TYPE_LENGTH ? `${stripped.slice(0, MAX_DISPLAYED_REC_TYPE_LENGTH)}\u2026` : stripped;
+}
+function readUnknownRecordEnvelope(json) {
+  if (typeof json !== "object" || json === null) return void 0;
+  const rec = json.rec;
+  const t = json.t;
+  if (typeof rec !== "string" || typeof t !== "string") return void 0;
+  const shaRaw = json.sha256;
+  const sha256 = typeof shaRaw === "string" && SHA256_HEX.test(shaRaw) ? shaRaw : void 0;
+  return { rec, t, sha256 };
+}
+function classifySpoolLine(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return { kind: "skipped", reason: "not valid JSON" };
+  }
+  const tombstone = ArtifactTombstoneRecordSchema.safeParse(json);
+  if (tombstone.success) return { kind: "tombstone", artifactId: tombstone.data.artifactId };
+  const parsed = ArtifactSpoolRecordSchema.safeParse(json);
+  if (parsed.success) return { kind: "record", record: parsed.data };
+  const envelope = readUnknownRecordEnvelope(json);
+  if (envelope !== void 0 && !KNOWN_SPOOL_RECORD_TYPES.has(envelope.rec)) {
+    const sanitizedRecType = sanitizeRecType(envelope.rec);
+    const recType = sanitizedRecType === "" ? "(empty)" : `"${sanitizedRecType}"`;
+    return {
+      kind: "held",
+      reason: `unrecognized record type ${recType} \u2014 this build's schemas do not recognize it`,
+      ...envelope.sha256 !== void 0 ? { sha256: envelope.sha256 } : {}
+    };
+  }
+  const issue = parsed.error.issues[0];
+  const issueDetail = issue ? ` (${issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""}${sanitizeTerminal(issue.message)})` : "";
+  return { kind: "skipped", reason: `does not match the artifact spool record shape${issueDetail}` };
+}
+function legacySidecarPaths(home) {
+  const dir = join(home, ".outerlayer", "spool");
+  return [
+    join(dir, "artifacts.watermark"),
+    join(dir, "artifacts.uploaded.json"),
+    join(dir, "artifacts.dropped.json"),
+    join(dir, "artifacts.held-offsets.json"),
+    join(dir, "artifacts.pending-first-seen.json")
+  ];
+}
+function readLegacySidecars(home) {
+  const dir = join(home, ".outerlayer", "spool");
+  let watermark = 0;
+  try {
+    const n = parseInt(readFileSync(join(dir, "artifacts.watermark"), "utf8").trim(), 10);
+    if (Number.isFinite(n) && n >= 0) watermark = n;
+  } catch {
+  }
+  const readIdSet = (name) => {
+    try {
+      const raw = JSON.parse(readFileSync(join(dir, name), "utf8"));
+      return new Set(Array.isArray(raw) ? raw.filter((v) => typeof v === "string") : []);
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  };
+  let pendingFirstSeen = {};
+  try {
+    const raw = JSON.parse(readFileSync(join(dir, "artifacts.pending-first-seen.json"), "utf8"));
+    if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+      const out = {};
+      for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "string") out[key] = value;
+      }
+      pendingFirstSeen = out;
+    }
+  } catch {
+  }
+  return {
+    watermark,
+    uploadedIds: readIdSet("artifacts.uploaded.json"),
+    droppedIds: readIdSet("artifacts.dropped.json"),
+    pendingFirstSeen
+  };
+}
+function computeMigratedState(home) {
+  const legacy = readLegacySidecars(home);
+  const state = /* @__PURE__ */ new Map();
+  const tombstoned = /* @__PURE__ */ new Set();
+  const rawRecords = [];
+  walkArtifactSpoolLines(home, (text, offset) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "tombstone") {
+      tombstoned.add(classified.artifactId);
+    } else if (classified.kind === "record") {
+      rawRecords.push({
+        artifactId: classified.record.artifactId,
+        offset,
+        sha256: classified.record.sha256,
+        t: classified.record.t
+      });
+    }
+  });
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  for (const { artifactId, offset, sha256, t } of rawRecords) {
+    if (offset >= legacy.watermark) continue;
+    if (legacy.uploadedIds.has(artifactId)) {
+      state.set(artifactId, { state: "uploaded", attempts: 1, firstSeen: t || nowIso, sha256, reachedServer: true });
+      continue;
+    }
+    if (legacy.droppedIds.has(artifactId)) {
+      state.set(artifactId, {
+        state: "dropped",
+        attempts: 1,
+        firstSeen: legacy.pendingFirstSeen[artifactId] ?? t ?? nowIso,
+        sha256,
+        reachedServer: false
+      });
+      continue;
+    }
+    if (tombstoned.has(artifactId)) continue;
+    state.set(artifactId, { state: "dropped", attempts: 1, firstSeen: t || nowIso, sha256, reachedServer: true });
+  }
+  return state;
+}
+function readPersistedArtifactSpoolState(home) {
+  let raw;
+  try {
+    raw = readFileSync(artifactsStatePath(home), "utf8");
+  } catch {
+    return { state: /* @__PURE__ */ new Map(), corrupt: false };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const records = parsed !== null && typeof parsed === "object" && Array.isArray(parsed.records) ? parsed.records : void 0;
+    if (records === void 0) return { state: /* @__PURE__ */ new Map(), corrupt: true };
+    const state = /* @__PURE__ */ new Map();
+    for (const entry of records) {
+      if (entry === null || typeof entry !== "object") continue;
+      const e = entry;
+      if (typeof e.artifactId !== "string") continue;
+      if (e.state !== "pending" && e.state !== "uploaded" && e.state !== "held" && e.state !== "dropped") continue;
+      state.set(e.artifactId, {
+        state: e.state,
+        attempts: typeof e.attempts === "number" && Number.isFinite(e.attempts) ? e.attempts : 0,
+        firstSeen: typeof e.firstSeen === "string" ? e.firstSeen : (/* @__PURE__ */ new Date(0)).toISOString(),
+        sha256: typeof e.sha256 === "string" ? e.sha256 : "",
+        reachedServer: e.reachedServer === true
+      });
+    }
+    return { state, corrupt: false };
+  } catch {
+    return { state: /* @__PURE__ */ new Map(), corrupt: true };
+  }
+}
+var ARTIFACT_STATE_RESOLVED_CAP = 5e3;
+function writeArtifactSpoolState(state, home = homeFromEnv()) {
+  try {
+    const path = artifactsStatePath(home);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    const pending = [];
+    const resolved = [];
+    for (const pair of state.entries()) {
+      (pair[1].state === "uploaded" || pair[1].state === "dropped" ? resolved : pending).push(pair);
+    }
+    const cappedResolved = resolved.length > ARTIFACT_STATE_RESOLVED_CAP ? resolved.slice(-ARTIFACT_STATE_RESOLVED_CAP) : resolved;
+    const records = [...pending, ...cappedResolved].map(([artifactId, entry]) => ({ artifactId, ...entry }));
+    writeFileSync(tmp, JSON.stringify({ version: 1, records }));
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function migrateLegacyArtifactSidecars(home = homeFromEnv()) {
+  if (existsSync(artifactsStatePath(home))) return;
+  const paths = legacySidecarPaths(home);
+  if (!paths.some((p) => existsSync(p))) return;
+  writeArtifactSpoolState(computeMigratedState(home), home);
+  for (const p of paths) {
+    try {
+      unlinkSync(p);
+    } catch {
+    }
+  }
+}
+function readEffectiveArtifactSpoolState(home = homeFromEnv()) {
+  const { state: persisted, corrupt } = existsSync(artifactsStatePath(home)) ? readPersistedArtifactSpoolState(home) : { state: computeMigratedState(home), corrupt: false };
+  const state = new Map(persisted);
+  const tombstonedIds = /* @__PURE__ */ new Set();
+  walkArtifactSpoolLines(home, (text) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "tombstone") tombstonedIds.add(classified.artifactId);
+  });
+  if (tombstonedIds.size > 0) {
+    walkArtifactSpoolLines(home, (text) => {
+      const classified = classifySpoolLine(text);
+      if (classified.kind !== "record") return;
+      const { record } = classified;
+      if (!tombstonedIds.has(record.artifactId)) return;
+      const existing = state.get(record.artifactId);
+      if (existing === void 0 || existing.state === "held" || existing.state === "pending") {
+        state.set(record.artifactId, {
+          state: "dropped",
+          attempts: existing?.attempts ?? 0,
+          firstSeen: existing?.firstSeen ?? record.t,
+          sha256: record.sha256,
+          reachedServer: false
+        });
+      }
+    });
+  }
+  return { state, corrupt };
+}
+function planArtifactUpload(opts = {}) {
+  const home = opts.home ?? homeFromEnv();
+  const { state: effective, corrupt } = readEffectiveArtifactSpoolState(home);
+  const state = new Map(effective);
+  const candidates = [];
+  const skipped = [];
+  const held = [];
+  const tombstonedIds = /* @__PURE__ */ new Set();
+  walkArtifactSpoolLines(home, (text) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "tombstone") tombstonedIds.add(classified.artifactId);
+  });
+  walkArtifactSpoolLines(home, (text, offset) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "tombstone") return;
+    if (classified.kind === "skipped") {
+      skipped.push({ offset, reason: classified.reason });
+      return;
+    }
+    if (classified.kind === "held") {
+      held.push({ offset, reason: classified.reason, ...classified.sha256 !== void 0 ? { sha256: classified.sha256 } : {} });
+      return;
+    }
+    const { record } = classified;
+    if (tombstonedIds.has(record.artifactId)) return;
+    const existing = state.get(record.artifactId);
+    if (existing === void 0 || existing.state === "held" || existing.state === "pending") {
+      candidates.push({ record });
+    }
+  });
+  return { candidates, state, skipped, held, corrupt };
+}
+function neededArtifactShas(home, finalState) {
+  const needed = /* @__PURE__ */ new Set();
+  walkArtifactSpoolLines(home, (text) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "held") {
+      if (classified.sha256 !== void 0) needed.add(classified.sha256);
+      return;
+    }
+    if (classified.kind !== "record") return;
+    const entry = finalState.get(classified.record.artifactId);
+    if (entry === void 0 || entry.state === "held" || entry.state === "pending") needed.add(classified.record.sha256);
+  });
+  return needed;
+}
+function reclaimUnneededArtifactBlobs(home, neededShas) {
+  let names;
+  try {
+    names = readdirSync(artifactBlobsDir(home));
+  } catch {
+    return 0;
+  }
+  let reclaimed = 0;
+  for (const name of names) {
+    if (!SHA256_HEX.test(name) || neededShas.has(name)) continue;
+    try {
+      unlinkSync(join(artifactBlobsDir(home), name));
+      reclaimed += 1;
+    } catch {
+    }
+  }
+  return reclaimed;
+}
+function localArtifactIds(home = homeFromEnv()) {
+  const ids = /* @__PURE__ */ new Set();
+  walkArtifactSpoolLines(home, (text) => {
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "record") ids.add(classified.record.artifactId);
+  });
+  return ids;
+}
+function findPendingArtifactRecord(artifactId, home = homeFromEnv()) {
+  let found;
+  walkArtifactSpoolLines(home, (text) => {
+    if (found !== void 0) return;
+    const classified = classifySpoolLine(text);
+    if (classified.kind === "record" && classified.record.artifactId === artifactId) found = classified.record;
+  });
+  if (found === void 0) return void 0;
+  const { state } = readEffectiveArtifactSpoolState(home);
+  const entry = state.get(artifactId);
+  if (entry !== void 0 && entry.state !== "held" && entry.state !== "pending") return void 0;
+  return { record: found };
+}
+function resolveArtifactTurnIndex(turns, filename) {
+  let found;
+  for (const turn of turns) {
+    for (const call of turn.toolCalls ?? []) {
+      const haystack = [
+        call.name,
+        typeof call.input === "string" ? call.input : call.input === void 0 ? "" : JSON.stringify(call.input),
+        typeof call.output === "string" ? call.output : call.output === void 0 ? "" : JSON.stringify(call.output),
+        call.file ?? ""
+      ].join("\n");
+      if (haystack.includes("emit artifact") && haystack.includes(filename)) found = turn.index;
+    }
+  }
+  return found;
+}
+
+export { ARTIFACT_RETRY_MAX_AGE_MS, appendArtifactRecord, appendArtifactTombstone, artifactBlobsDir, artifactsSpoolPath, artifactsStatePath, findPendingArtifactRecord, isArtifactTombstoned, localArtifactIds, migrateLegacyArtifactSidecars, neededArtifactShas, planArtifactUpload, readEffectiveArtifactSpoolState, reclaimUnneededArtifactBlobs, resolveArtifactTurnIndex, sanitizeTerminal, writeArtifactSpoolState };

package/dist/{chunk-A3WLZX2F.js → chunk-WIOZAJ2W.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-KFYJV2ZG.js';
+import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-EMY4I27X.js';
 import { readFileSync, existsSync, writeFileSync, mkdirSync, utimesSync, statSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 
@@ -116,5 +116,18 @@ function writeSourceCache(gitCommonDir, cache) {
 function isSourceCacheFresh(cache, now) {
   return now - Date.parse(cache.checkedAt) < cache.ttlMs;
 }
+function buildHoldPath(gitCommonDir) {
+  return join(stateDir(gitCommonDir), "build-hold.json");
+}
+function readBuildHold(gitCommonDir) {
+  const parsed = readJson(buildHoldPath(gitCommonDir));
+  if (parsed && typeof parsed.sha === "string" && typeof parsed.repository === "string" && typeof parsed.ref === "string" && typeof parsed.at === "string") {
+    return parsed;
+  }
+  return void 0;
+}
+function writeBuildHold(gitCommonDir, hold) {
+  writeJson(buildHoldPath(gitCommonDir), hold);
+}
 
-export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, isLastCheckFresh, isSourceCacheFresh, manifestFilesPresent, pinExists, readContextManifest, readDegraded, readPin, readSourceCache, touchLastCheck, writeContextManifest, writeDegraded, writePinIfChanged, writeSourceCache };
+export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, isLastCheckFresh, isSourceCacheFresh, manifestFilesPresent, pinExists, readBuildHold, readContextManifest, readDegraded, readPin, readSourceCache, touchLastCheck, writeBuildHold, writeContextManifest, writeDegraded, writePinIfChanged, writeSourceCache };

package/dist/chunk-WO2BXCTQ.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { splitRawFile } from './chunk-EMY4I27X.js';
+import { resolvePackageVersion } from './chunk-RA3O54FC.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+createRequire(import.meta.url);
+var TEMPLATE_SKILLS = ["spec", "writing-specs", "build"];
+var MAINTAINED_SKILLS = ["emitting-evidence", "amend", "reporting-findings", "outerlayer"];
+var TEMPLATE_CLASS_LINE = "<!-- yours to edit. Copied once from the default template by outerlayer init; never overwritten. -->";
+function maintainedClassLine(version) {
+  return `<!-- maintained by OuterLayer ${version}. Edits are overwritten on the next outerlayer context emit. -->`;
+}
+function resolvePackRoot(entryPath = fileURLToPath(import.meta.url)) {
+  return join(dirname(dirname(entryPath)), "skill-pack");
+}
+function skillDir(skill) {
+  return `.outerlayer/skills/${skill}`;
+}
+function renderSkillFile(skillClass, content, version) {
+  const line = skillClass === "maintained" ? maintainedClassLine(version) : TEMPLATE_CLASS_LINE;
+  const { frontmatterInner, body } = splitRawFile(content);
+  if (frontmatterInner === null) return `${line}
+${content}`;
+  const block = content.slice(0, content.length - body.length);
+  return `${block}${block.endsWith("\n") ? "" : "\n"}${line}
+${body}`;
+}
+function filesUnder(dir, base = dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...filesUnder(abs, base));
+    else if (entry.isFile()) out.push(abs.slice(base.length + 1).split("\\").join("/"));
+  }
+  return out.sort();
+}
+function orderSkillFiles(relPaths) {
+  return [...relPaths.filter((p) => p === "SKILL.md"), ...relPaths.filter((p) => p !== "SKILL.md")];
+}
+function loadClass(packRoot, skillClass, names, version) {
+  const files = [];
+  for (const skill of names) {
+    const dir = join(packRoot, skillClass, skill);
+    if (!existsSync(dir)) throw new Error(`skill pack is missing ${skillClass}/${skill} under ${packRoot}`);
+    for (const rel of orderSkillFiles(filesUnder(dir))) {
+      const raw = readFileSync(join(dir, rel), "utf8");
+      files.push({
+        skill,
+        skillClass,
+        path: `${skillDir(skill)}/${rel}`,
+        content: rel === "SKILL.md" ? renderSkillFile(skillClass, raw, version) : raw
+      });
+    }
+  }
+  return files;
+}
+function loadTemplateFiles(packRoot = resolvePackRoot(), version = resolvePackageVersion()) {
+  return loadClass(packRoot, "template", TEMPLATE_SKILLS, version);
+}
+function loadMaintainedFiles(packRoot = resolvePackRoot(), version = resolvePackageVersion()) {
+  return loadClass(packRoot, "maintained", MAINTAINED_SKILLS, version);
+}
+function writeMaintainedFiles(repoRoot, files) {
+  const created = [];
+  const rewritten = [];
+  for (const file of files) {
+    const abs = join(repoRoot, file.path);
+    const exists = existsSync(abs);
+    if (exists && readFileSync(abs, "utf8") === file.content) continue;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, file.content);
+    (exists ? rewritten : created).push(file.path);
+  }
+  return { created, rewritten };
+}
+function maintainedFilesForExistingSkills(repoRoot, files) {
+  return files.filter((file) => existsSync(join(repoRoot, skillDir(file.skill))));
+}
+
+export { MAINTAINED_SKILLS, TEMPLATE_SKILLS, loadMaintainedFiles, loadTemplateFiles, maintainedFilesForExistingSkills, resolvePackRoot, skillDir, writeMaintainedFiles };

package/dist/{chunk-I3ETLSNE.js → chunk-XCCLFVXM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { readFileSync, readdirSync, existsSync, mkdirSync, writeFileSync, unlinkSync, chmodSync } from 'fs';
+import { mkdirSync, chmodSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync } from 'fs';
 import { join, isAbsolute, dirname, basename, resolve } from 'path';
 import { execFileSync } from 'child_process';
 
@@ -74,8 +74,103 @@ function contextExcludesPresent(gitCommonDir) {
   if (beginIdx === -1) return false;
   return BLOCK_LINES.every((l, i) => lines[beginIdx + i] === l);
 }
-var JOURNAL_HOOK_MARKER = "# outerlayer post-rewrite journal";
+var HOOKS_DIR_NAME = "git-hooks";
+var CO_AUTHOR_FILE = "co-author";
+var HOOKS = [
+  "applypatch-msg",
+  "pre-applypatch",
+  "post-applypatch",
+  "pre-commit",
+  "pre-merge-commit",
+  "prepare-commit-msg",
+  "commit-msg",
+  "post-commit",
+  "pre-rebase",
+  "post-checkout",
+  "post-merge",
+  "pre-push",
+  "pre-receive",
+  "update",
+  "post-receive",
+  "post-update",
+  "reference-transaction",
+  "pre-auto-gc",
+  "post-rewrite",
+  "sendemail-validate",
+  "post-index-change"
+];
+var READS_STDIN = /* @__PURE__ */ new Set(["pre-push", "pre-receive", "post-receive", "reference-transaction", "post-rewrite"]);
 var PRE_COMMIT_GUARD_MARKER = "# outerlayer materialized-context commit guard";
+var RUN_GUARD = `common=$(git rev-parse --git-common-dir 2>/dev/null)
+guard=$common/hooks/pre-commit
+if [ "$guard" != "$hook" ] && [ -f "$guard" ] && [ -x "$guard" ] &&
+  sed -n 2p "$guard" | grep -q '^${PRE_COMMIT_GUARD_MARKER}'; then
+  "$guard" "$@" || exit $?
+fi
+`;
+var ADD_TRAILER = `
+# Every commit of the build names the requester once: a trailer already there is left alone.
+file=\${1-}
+if [ -n "$file" ] && [ -f "$file" ]; then
+  git interpret-trailers --in-place --if-exists addIfDifferent --trailer "Co-authored-by: $(cat "$here/${CO_AUTHOR_FILE}")" "$file" ||
+    echo "outerlayer: could not add the co-author line to the commit message" >&2
+fi
+`;
+var HOOK_WRAPPER_MARKER = "# Written by the OuterLayer runner.";
+function script(name) {
+  const adds = name === "prepare-commit-msg";
+  return `#!/bin/sh
+${HOOK_WRAPPER_MARKER} Runs the repository's own ${name} hook, then
+# ${adds ? "adds the co-author line to the commit message" : "hands its status on"}.
+here=$(dirname "$0")
+
+# The hooks path git would use without this directory: cut the list of configuration
+# entries the runner passes just before its own core.hooksPath entry, then ask git.
+n=\${GIT_CONFIG_COUNT-0}
+case $n in '' | *[!0-9]*) n=0 ;; esac
+cut=$n
+i=$n
+while [ "$i" -gt 0 ]; do
+  i=$((i - 1))
+  eval "key=\\\${GIT_CONFIG_KEY_$i-}"
+  eval "value=\\\${GIT_CONFIG_VALUE_$i-}"
+  if [ "$key" = core.hooksPath ] && { [ "$value" = "$here" ] || [ "$value" -ef "$here" ]; }; then
+    cut=$i
+    break
+  fi
+done
+path=$(GIT_CONFIG_COUNT=$cut git config --type=path core.hooksPath 2>/dev/null) || path=
+if [ -z "$path" ]; then
+  path=$(git rev-parse --git-common-dir 2>/dev/null)/hooks
+fi
+
+hook=$path/${name}
+${name === "pre-commit" ? RUN_GUARD : ""}status=0
+if [ "$path" -ef "$here" ] || [ ! -f "$hook" ] || [ ! -x "$hook" ]; then
+${READS_STDIN.has(name) ? "  cat >/dev/null\n" : ""}  :
+else
+${adds ? `  "$hook" "$@" || status=$?` : `  exec "$hook" "$@"`}
+fi
+${adds ? `[ "$status" -eq 0 ] || exit "$status"
+${ADD_TRAILER}` : ""}exit 0
+`;
+}
+function writeCommitHooks(buildDir, coAuthor) {
+  const dir = join(buildDir, HOOKS_DIR_NAME);
+  mkdirSync(dir, { recursive: true });
+  chmodSync(dir, 493);
+  for (const name of HOOKS) {
+    const path = join(dir, name);
+    writeFileSync(path, script(name));
+    chmodSync(path, 493);
+  }
+  const data = join(dir, CO_AUTHOR_FILE);
+  writeFileSync(data, `${coAuthor.name} <${coAuthor.email}>
+`);
+  chmodSync(data, 420);
+  return dir;
+}
+var JOURNAL_HOOK_MARKER = "# outerlayer post-rewrite journal";
 var PRE_COMMIT_GUARD_VERSION = `${PRE_COMMIT_GUARD_MARKER} v1`;
 var PRE_COMMIT_GUARD_BODY_SIGNATURE = "outerlayer: refusing to commit materialized control-plane context";
 var PRE_COMMIT_GUARD_SCRIPT = `#!/bin/sh
@@ -114,8 +209,8 @@ exit 1
 function managedHookScripts() {
   return [["pre-commit", printableHookScript(PRE_COMMIT_GUARD_SCRIPT)]];
 }
-function printableHookScript(script) {
-  const lines = script.split("\n");
+function printableHookScript(script2) {
+  const lines = script2.split("\n");
   return [lines[0], ...lines.slice(2)].join("\n");
 }
 function git(cwd, args) {
@@ -141,7 +236,7 @@ function commonHooksDir(cwd) {
   if (rel === void 0) return void 0;
   return join(isAbsolute(rel) ? rel : join(cwd, rel), "hooks");
 }
-function installHookFile(dir, name, script, marker) {
+function installHookFile(dir, name, script2, marker) {
   const path = join(dir, name);
   let existing;
   try {
@@ -151,7 +246,7 @@ function installHookFile(dir, name, script, marker) {
   }
   if (existing !== void 0) {
     if (!isOwnRecognitionLine(existing, marker)) return "skipped-foreign";
-    if (existing === script) {
+    if (existing === script2) {
       try {
         chmodSync(path, 493);
       } catch {
@@ -160,7 +255,7 @@ function installHookFile(dir, name, script, marker) {
     }
   }
   mkdirSync(dir, { recursive: true });
-  writeFileSync(path, script);
+  writeFileSync(path, script2);
   chmodSync(path, 493);
   return existing === void 0 ? "installed" : "updated";
 }
@@ -237,15 +332,29 @@ function expandHooksPathTilde(hooksPath) {
 }
 function ensurePreCommitGuardHook(repoRoot, gitCommonDir) {
   const hooksPath = git(repoRoot, ["config", "core.hooksPath"]) ?? "";
-  if (hooksPath !== "") {
+  if (hooksPath !== "" && !isRunnerHookWrapper(hooksPath, repoRoot)) {
     const expanded = expandHooksPathTilde(hooksPath);
     const effectivePath = isAbsolute(expanded) ? join(expanded, "pre-commit") : join(repoRoot, expanded, "pre-commit");
     return { status: "skipped-custom-hooks-path", adopted: guardAdoptedAtEffectiveHook(effectivePath) };
   }
+  return installPreCommitGuardInGitDir(gitCommonDir);
+}
+function installPreCommitGuardInGitDir(gitCommonDir) {
   const path = join(gitCommonDir, "hooks", "pre-commit");
   const status = installHookFile(join(gitCommonDir, "hooks"), "pre-commit", PRE_COMMIT_GUARD_SCRIPT, PRE_COMMIT_GUARD_MARKER);
   return { status, adopted: status === "skipped-foreign" ? guardBodyPresent(path) : true };
 }
+function isRunnerHookWrapper(hooksPath, repoRoot) {
+  const dir = resolve(repoRoot, expandHooksPathTilde(hooksPath));
+  if (basename(dir) !== HOOKS_DIR_NAME) return false;
+  try {
+    const script2 = readFileSync(join(dir, "pre-commit"), "utf8");
+    const secondLine = script2.indexOf("\n") + 1;
+    return secondLine > 0 && script2.startsWith(HOOK_WRAPPER_MARKER, secondLine);
+  } catch {
+    return false;
+  }
+}
 function deadHooksState(cwd) {
   const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
   if (inRepo !== "true") return { dead: false };
@@ -282,11 +391,11 @@ function preparePackageManagerCommand(repoRoot) {
 function huskyPrepareScript(repoRoot) {
   try {
     const pkg = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
-    const script = pkg.scripts?.prepare;
-    if (typeof script === "string" && /husky/i.test(script)) return script;
+    const script2 = pkg.scripts?.prepare;
+    if (typeof script2 === "string" && /husky/i.test(script2)) return script2;
   } catch {
   }
   return null;
 }
 
-export { contextExcludesPresent, deadHooksState, ensureContextExcludes, ensurePreCommitGuardHook, huskyPrepareScript, installPreCommitGuardHook, managedHookScripts, preparePackageManagerCommand, removeJournalHooks, removePreCommitGuardHook };
+export { HOOKS_DIR_NAME, contextExcludesPresent, deadHooksState, ensureContextExcludes, ensurePreCommitGuardHook, huskyPrepareScript, installPreCommitGuardHook, installPreCommitGuardInGitDir, managedHookScripts, preparePackageManagerCommand, removeJournalHooks, removePreCommitGuardHook, writeCommitHooks };