@outerlayer/cli 0.11.0 → 0.13.0

package/dist/emit-finding-cmd-P4RKBPBB.js

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { launchRefusalForSession } from './chunk-HHJDN6AU.js';
+import { autoConnect } from './chunk-EFZLAYPE.js';
+import { detectActiveSession, transcriptPathForSession } from './chunk-IP7BIBXJ.js';
+import './chunk-4QVZCVWT.js';
+import './chunk-CNFVHDHG.js';
+import { resolveRepoIdentity, defaultProjectsDir, findTranscripts, sessionIdFromPath, scrubText } from './chunk-JXYVA45C.js';
+import './chunk-4KSQKQXE.js';
+import './chunk-N6LURUEF.js';
+import './chunk-YRYMNBGQ.js';
+import { launchedItemForSession } from './chunk-GQD22KKN.js';
+import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
+import { readLatestProvenanceForSession } from './chunk-ZJSNLVCE.js';
+import { defaultFetch } from './chunk-YO4PSLVB.js';
+import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-PLMTLGYH.js';
+import { FindingBatchSchema, FindingsResponseSchema, SAME_PROBLEM_RULES } from './chunk-J5M7BSJQ.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-V7NIVOFD.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-BJ3KTMDH.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var RECENT_EVENT_COUNT = 30;
+var SUMMARY_MAX = 110;
+function locateTranscript(sessionId, home) {
+  const fromSpool = transcriptPathForSession(sessionId, home);
+  if (fromSpool !== void 0 && existsSync(fromSpool)) return fromSpool;
+  const root = home === "" ? defaultProjectsDir() : join(home, ".claude", "projects");
+  return findTranscripts(root).find((entry) => !entry.isSubagent && sessionIdFromPath(entry.file) === sessionId)?.file;
+}
+function blockText(block) {
+  if (typeof block === "string") return block;
+  if (typeof block !== "object" || block === null) return "";
+  const b = block;
+  if (b.type === "text" && typeof b.text === "string") return b.text;
+  if (b.type === "tool_use") {
+    const input = b.input ?? {};
+    const detail = [input.command, input.file_path, input.pattern, input.description, input.prompt, input.url].find((v) => typeof v === "string");
+    return `${String(b.name ?? "tool")}: ${detail ?? ""}`;
+  }
+  if (b.type === "tool_result") {
+    const content = b.content;
+    const inner = typeof content === "string" ? content : Array.isArray(content) ? content.map(blockText).join(" ") : "";
+    return `result: ${inner}`;
+  }
+  return "";
+}
+function summarize(type, message) {
+  const content = typeof message === "object" && message !== null ? message.content : void 0;
+  const text = Array.isArray(content) ? content.map(blockText).join(" ") : blockText(content);
+  const flat = scrubText(text.replace(/\s+/g, " ").trim());
+  const clipped = flat.length > SUMMARY_MAX ? `${flat.slice(0, SUMMARY_MAX - 1)}\u2026` : flat;
+  return `${type === "user" ? "user" : "agent"}: ${clipped}`;
+}
+function readSessionEvents(transcriptPath) {
+  let text;
+  try {
+    text = readFileSync(transcriptPath, "utf8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  text.split("\n").forEach((line, index) => {
+    if (line.trim() === "") return;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (record.type !== "user" && record.type !== "assistant" || typeof record.timestamp !== "string") return;
+    if (!Number.isFinite(Date.parse(record.timestamp))) return;
+    events.push({ id: `e${index + 1}`, at: record.timestamp, summary: summarize(record.type, record.message) });
+  });
+  return events;
+}
+function recentSessionEvents(sessionId, home, count = RECENT_EVENT_COUNT) {
+  const path = locateTranscript(sessionId, home);
+  if (path === void 0) return void 0;
+  return readSessionEvents(path).slice(-count);
+}
+var SessionEventNotFoundError = class extends Error {
+};
+function loadSessionEvents(sessionId, home) {
+  const path = locateTranscript(sessionId, home);
+  return path === void 0 ? void 0 : readSessionEvents(path);
+}
+function pickSessionEvent(events, id) {
+  if (events === void 0) {
+    throw new SessionEventNotFoundError(`event ${id}: this session's transcript was not found on this machine`);
+  }
+  const found = events.find((event) => event.id === id);
+  if (found === void 0) {
+    throw new SessionEventNotFoundError(`event ${id} is not in this session's transcript \u2014 pick an id from the list \`outerlayer emit finding\` prints`);
+  }
+  return { id: found.id, at: found.at };
+}
+
+// src/emit-finding-output.ts
+var NEEDS_CHOICE_EXIT_CODE = 3;
+function clock(iso) {
+  const date = new Date(iso);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+}
+function formatRecentEvents(events) {
+  if (events.length === 0) return "";
+  const lines = events.map((event) => `  ${event.id.padEnd(7)} ${clock(event.at)}  ${event.summary}`);
+  return [
+    "Recent events in this session (id, local time, what happened):",
+    ...lines,
+    "To record time lost, run again with --started-at <id of the event where you first hit the problem>",
+    "and --ended-at <id of the event where you got past it>. The time is read from those events."
+  ].join("\n");
+}
+function plain(text) {
+  return text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ").trim();
+}
+function quoted(title) {
+  return `"${plain(title)}"`;
+}
+function storedLine(result) {
+  const problems = result.problems ?? [];
+  const where = problems.length === 0 ? "" : ` \u2192 ${problems.map((p) => `problem ${plain(p.id)} ${quoted(p.title)}`).join(", ")}`;
+  const how = result.method === "kept" ? " (kept the problems it already had)" : result.method ? ` (${result.method})` : "";
+  const lines = [`  ${result.id}${where}${how}`];
+  for (const replaced of result.overridden ?? []) {
+    lines.push(`    ${quoted(replaced.title)} (${plain(replaced.id)}) was not linked: a key of this finding is owned by the problem above`);
+  }
+  return lines.join("\n");
+}
+function formatStored(results) {
+  const stored = results.filter((r) => r.outcome === "stored");
+  if (stored.length === 0) return "";
+  return ["Joined problems:", ...stored.map(storedLine)].join("\n");
+}
+function formatCandidates(results, rerun) {
+  const pending = results.filter((r) => r.outcome === "needs_choice");
+  if (pending.length === 0) return "";
+  const blocks = [];
+  for (const result of pending) {
+    const lines = [`Finding ${result.id} was not stored. These problems may be the same one:`];
+    for (const candidate of result.candidates ?? []) {
+      lines.push(
+        "",
+        `  ${plain(candidate.id)}  ${quoted(candidate.title)}  (${candidate.reportCount} ${candidate.reportCount === 1 ? "report" : "reports"})`
+      );
+      for (const report of candidate.reports) {
+        const cause = report.cause ? `cause: ${plain(report.cause)}` : "cause: not recorded";
+        lines.push(`    - ${quoted(report.title)}  ${cause}${report.file ? `  (${plain(report.file)})` : ""}`);
+      }
+    }
+    blocks.push(lines.join("\n"));
+  }
+  return [blocks.join("\n\n"), "", "What counts as the same problem:", SAME_PROBLEM_RULES, "", rerun].join("\n");
+}
+var RERUN_SINGLE = 'Run the same command again with --problem <id> --link-reason "<why>" (one --problem for each problem this finding reports), or with --new if none of these is the same problem.';
+function rerunBatch(file) {
+  const target = file === "-" ? "the batch" : file;
+  return `In ${target}, give each finding listed above "problems": [<id>, ...] with "linkReason": "<why>", or "new": true if none of these is the same problem. Then run emit findings again: the findings already stored are updated in place.`;
+}
+
+// src/emit-finding-cmd.ts
+var GREEN = "\x1B[32m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var EmitFindingError = class extends Error {
+};
+var REMOVED_FINDING_FLAGS = ["subject", "kind", "severity", "verdict", "fixed", "source"];
+function refuseRemovedFindingFlags(opts) {
+  const used = REMOVED_FINDING_FLAGS.find((flag) => opts[flag] !== void 0);
+  if (used === void 0) return;
+  throw new EmitFindingError(
+    `--${used} is no longer accepted: findings record problems in the factory, not review verdicts. Pass --category <context|flaky-test|tooling|environment|defect|other> instead.`
+  );
+}
+function parseItemFlag(raw) {
+  if (raw === void 0) return void 0;
+  const number = parseTrackerNumber(raw);
+  if (number === void 0) {
+    throw new EmitFindingError(trackerNumberError("--item", raw));
+  }
+  return { number };
+}
+function parseIntFlag(raw, flag, opts) {
+  if (raw === void 0) return void 0;
+  if (!/^-?\d+$/.test(raw)) {
+    throw new EmitFindingError(`invalid ${flag} "${raw}" \u2014 expected a whole number`);
+  }
+  const n = Number(raw);
+  if (!Number.isSafeInteger(n) || n < opts.min) {
+    throw new EmitFindingError(`invalid ${flag} "${raw}" \u2014 expected a whole number >= ${opts.min}`);
+  }
+  return n;
+}
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+function recordFromFlags(opts) {
+  const line = parseIntFlag(opts.line, "--line", { min: 1 });
+  const ruleLine = parseIntFlag(opts.ruleLine, "--rule-line", { min: 1 });
+  const turnIndex = parseIntFlag(opts.turn, "--turn", { min: 0 });
+  const round = parseIntFlag(opts.round, "--round", { min: 0 });
+  const hasRule = opts.rulePath !== void 0 || opts.ruleQuote !== void 0 || opts.ruleRelation !== void 0 || ruleLine !== void 0;
+  return {
+    id: opts.id,
+    category: opts.category,
+    title: opts.title,
+    file: opts.file,
+    line: line ?? null,
+    rule: hasRule ? {
+      path: opts.rulePath,
+      line: ruleLine ?? null,
+      ...opts.ruleQuote !== void 0 ? { quote: opts.ruleQuote } : {},
+      relation: opts.ruleRelation
+    } : null,
+    where: {
+      label: opts.where,
+      ...opts.traceId !== void 0 ? { traceId: opts.traceId } : {},
+      ...turnIndex !== void 0 ? { turnIndex } : {},
+      ...round !== void 0 ? { round } : {}
+    },
+    detail: opts.detail,
+    cause: opts.cause,
+    suggestion: opts.suggestion,
+    command: opts.command,
+    error: opts.error,
+    test: opts.test,
+    symbol: opts.symbol,
+    ...opts.problem !== void 0 && opts.problem.length > 0 ? { problems: opts.problem } : {},
+    linkReason: opts.linkReason,
+    ...opts.new === true ? { new: true } : {},
+    // Event ids, resolved to { id, at } against the session transcript
+    // before the batch is validated.
+    startedAt: opts.startedAt,
+    endedAt: opts.endedAt
+  };
+}
+function resolveEvents(finding, sessionId, loadEvents) {
+  const out = { ...finding };
+  for (const key of ["startedAt", "endedAt"]) {
+    const value = out[key];
+    if (typeof value !== "string") continue;
+    if (sessionId === void 0) {
+      throw new EmitFindingError(
+        `${key === "startedAt" ? "--started-at" : "--ended-at"} names an event of the recording session, but no recorded session was found here`
+      );
+    }
+    try {
+      out[key] = pickSessionEvent(loadEvents(sessionId), value);
+    } catch (err) {
+      throw new EmitFindingError(err.message);
+    }
+  }
+  return out;
+}
+function eventLoader(home) {
+  let loaded = false;
+  let events;
+  return (sessionId) => {
+    if (!loaded) {
+      events = loadSessionEvents(sessionId, home);
+      loaded = true;
+    }
+    return events;
+  };
+}
+function firstIssueMessage(result) {
+  const issue = result.error.issues[0];
+  return issue ? `${issue.path.join(".")}: ${issue.message}` : "malformed";
+}
+function detectUploadSessionId(opts) {
+  const identity = resolveRepoIdentity(opts.cwd);
+  return detectActiveSession({
+    env: opts.env,
+    home: opts.home,
+    cwds: identity.repoRoot !== void 0 ? [identity.repoRoot, opts.cwd] : [opts.cwd],
+    nowMs: opts.now().getTime()
+  });
+}
+function resolveUploadTarget(opts) {
+  const item = parseItemFlag(opts.item);
+  const sessionId = opts.sessionId;
+  if (sessionId !== void 0) {
+    const refusal = launchRefusalForSession(sessionId, opts.home);
+    if (refusal !== void 0) throw new EmitFindingError(refusal);
+  }
+  if (item !== void 0) {
+    return sessionId !== void 0 ? { item, sessionId } : { item };
+  }
+  if (sessionId === void 0) {
+    throw new EmitFindingError(
+      "nothing to attach this to \u2014 no work item. Pass --item <number>, or run inside a recorded session launched with OUTERLAYER_WORK \u2014 its own launch record names the item automatically."
+    );
+  }
+  const launchedNumber = launchedItemForSession(sessionId, opts.home);
+  if (launchedNumber === void 0) {
+    throw new EmitFindingError(
+      "nothing to attach this to \u2014 no work item. Pass --item <number>; this recorded session's own launch record names no item either."
+    );
+  }
+  return { item: { number: launchedNumber }, sessionId };
+}
+async function upload(batch, target, opts) {
+  const refusal = await autoConnect(opts);
+  if (refusal !== void 0) throw new EmitFindingError(refusal);
+  const resolved = resolveGatewayCredentials(opts);
+  if (!resolved.ok) throw new EmitFindingError(resolved.message);
+  const { url, credential: apiKey, appId } = resolved;
+  const request = {
+    ...batch,
+    item: target.item,
+    ...target.sessionId !== void 0 ? { sessionId: target.sessionId } : {}
+  };
+  const fetchImpl = opts.fetchImpl ?? defaultFetch;
+  const endpoint = new URL("/v1/findings", url).toString();
+  let response;
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        "x-outerlayer-app-id": appId
+      },
+      body: JSON.stringify(request)
+    });
+  } catch (err) {
+    throw new EmitFindingError(`network error reaching ${endpoint}: ${String(err)}`);
+  }
+  if (response.status === 401) {
+    throw new EmitFindingError(
+      unauthorizedMessage(apiKey)
+    );
+  }
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).replace(/\s+/g, " ").trim().slice(0, 160);
+    } catch {
+    }
+    throw new EmitFindingError(`emit failed (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+  let data = {};
+  try {
+    data = (await response.json()).data ?? {};
+  } catch {
+  }
+  const count = typeof data.count === "number" ? data.count : batch.findings.length;
+  const parsedResponse = FindingsResponseSchema.safeParse(data);
+  const results = parsedResponse.success ? parsedResponse.data.results : [];
+  const needsChoice = results.some((r) => r.outcome === "needs_choice");
+  const exitCode = needsChoice ? NEEDS_CHOICE_EXIT_CODE : 0;
+  let output;
+  if (opts.json) {
+    output = JSON.stringify(data);
+  } else {
+    const summary = `${GREEN}\u2713${RESET} recorded ${count} ${count === 1 ? "finding" : "findings"} ${DIM}\xB7${RESET} item #${target.item.number}`;
+    output = [
+      opts.eventsBlock ?? "",
+      count > 0 || !needsChoice ? summary : "",
+      formatStored(results),
+      formatCandidates(results, opts.rerun)
+    ].filter((part) => part !== "").join("\n\n");
+  }
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output, exitCode };
+}
+async function runEmitFinding(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? homeFromEnv();
+  const env = opts.env ?? process.env;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const sessionId = detectUploadSessionId({ cwd, home, env, now });
+  const contextSourceSha = opts.contextSourceSha ?? (sessionId !== void 0 ? readLatestProvenanceForSession(sessionId, home)?.sha ?? void 0 : void 0);
+  const rawBatch = {
+    schemaVersion: 3,
+    ...opts.headSha !== void 0 ? { headSha: opts.headSha } : {},
+    ...contextSourceSha !== void 0 ? { contextSourceSha } : {},
+    findings: [resolveEvents(recordFromFlags(opts), sessionId, eventLoader(home))]
+  };
+  const parsed = FindingBatchSchema.safeParse(rawBatch);
+  if (!parsed.success) {
+    throw new EmitFindingError(`invalid finding \u2014 ${firstIssueMessage(parsed)}`);
+  }
+  const target = resolveUploadTarget({ item: opts.item, sessionId, home });
+  const events = opts.startedAt === void 0 && sessionId !== void 0 ? recentSessionEvents(sessionId, home) : void 0;
+  return upload(parsed.data, target, {
+    json: opts.json,
+    url: opts.url,
+    apiKey: opts.apiKey,
+    appId: opts.appId,
+    cwd,
+    quiet: opts.quiet,
+    home,
+    env,
+    fetchImpl: opts.fetchImpl,
+    eventsBlock: events !== void 0 && !opts.json ? formatRecentEvents(events) : void 0,
+    rerun: RERUN_SINGLE
+  });
+}
+async function runEmitFindings(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? homeFromEnv();
+  const env = opts.env ?? process.env;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  let text;
+  if (opts.file === "-") {
+    text = await (opts.readStdin ?? readAllStdin)();
+  } else {
+    try {
+      text = readFileSync(opts.file, "utf8");
+    } catch (err) {
+      throw new EmitFindingError(`cannot read "${opts.file}": ${String(err)}`);
+    }
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw new EmitFindingError(`"${opts.file}" is not valid JSON: ${String(err)}`);
+  }
+  const version = raw?.schemaVersion;
+  if (version === 1 || version === 2) {
+    throw new EmitFindingError(
+      `"${opts.file}" uses schemaVersion ${version}, which is no longer accepted. Use schemaVersion 3: each finding takes a category (context, flaky-test, tooling, environment, defect or other), and may carry detail, cause, suggestion, command, error, test, symbol, problems with linkReason, or new.`
+    );
+  }
+  const sessionId = detectUploadSessionId({ cwd, home, env, now });
+  if (Array.isArray(raw?.findings)) {
+    const batch = raw;
+    const loadEvents = eventLoader(home);
+    raw = {
+      ...batch,
+      findings: batch.findings.map(
+        (entry) => typeof entry === "object" && entry !== null ? resolveEvents(entry, sessionId, loadEvents) : entry
+      )
+    };
+  }
+  const parsed = FindingBatchSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new EmitFindingError(`invalid finding batch \u2014 ${firstIssueMessage(parsed)}`);
+  }
+  const target = resolveUploadTarget({ item: opts.item, sessionId, home });
+  return upload(parsed.data, target, {
+    json: opts.json,
+    url: opts.url,
+    apiKey: opts.apiKey,
+    appId: opts.appId,
+    cwd,
+    quiet: opts.quiet,
+    home,
+    env,
+    fetchImpl: opts.fetchImpl,
+    rerun: rerunBatch(opts.file)
+  });
+}
+
+export { EmitFindingError, refuseRemovedFindingFlags, runEmitFinding, runEmitFindings };

package/dist/{emit-result-cmd-GKBVPMU4.js → emit-result-cmd-6XYENU6H.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { detectCi } from './chunk-Y6P5XX2B.js';
+import { detectCi } from './chunk-3D4OYFCD.js';
 import { launchRefusalForSession } from './chunk-HHJDN6AU.js';
 import './chunk-TBT347UY.js';
 import './chunk-F7CU5ABH.js';
 import './chunk-BKO6JEZI.js';
-import { autoConnect } from './chunk-ZQ5JGHUO.js';
-import { detectActiveSession } from './chunk-BFESLKPP.js';
-import './chunk-UES67HLJ.js';
-import './chunk-VDI5POCC.js';
-import { resolveRepoIdentity } from './chunk-IU4NZROR.js';
-import './chunk-USO2DKBD.js';
+import { autoConnect } from './chunk-EFZLAYPE.js';
+import { detectActiveSession } from './chunk-IP7BIBXJ.js';
+import './chunk-4QVZCVWT.js';
+import './chunk-CNFVHDHG.js';
+import { resolveRepoIdentity } from './chunk-JXYVA45C.js';
+import './chunk-4KSQKQXE.js';
 import './chunk-N6LURUEF.js';
 import './chunk-YRYMNBGQ.js';
 import './chunk-GQD22KKN.js';
@@ -19,11 +19,11 @@ import './chunk-5QRP3MVS.js';
 import './chunk-ZJSNLVCE.js';
 import { defaultFetch } from './chunk-YO4PSLVB.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-PLMTLGYH.js';
-import { EmittedNameSchema, EMITTED_RESULT_MAX_LINK_LENGTH, EMITTED_RESULTS, EMITTED_RESULT_MAX_BODY_LENGTH } from './chunk-YT35WGIP.js';
+import { EmittedNameSchema, EMITTED_RESULT_MAX_LINK_LENGTH, EMITTED_RESULTS, EMITTED_RESULT_MAX_BODY_LENGTH } from './chunk-J5M7BSJQ.js';
 import './chunk-EABW6AJQ.js';
 import './chunk-V7NIVOFD.js';
 import './chunk-ZM2IMMYN.js';
-import './chunk-4HMXH2OA.js';
+import './chunk-SFFHGX3G.js';
 import './chunk-XCCLFVXM.js';
 import './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';

package/dist/{hook-fast-AQCAQIA6.js → hook-fast-PXWKQPN6.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { AUTO_SYNC_DEBOUNCE_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, contextPossiblyGoverned, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, logHookError, markWorkLeaseRenewed, maybeAutoSync, maybeRenewWorkLease, recordLinkExitFailure, runHookFast, spoolDir } from './chunk-4HMXH2OA.js';
+export { AUTO_SYNC_DEBOUNCE_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, contextPossiblyGoverned, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, logHookError, markWorkLeaseRenewed, maybeAutoSync, maybeRenewWorkLease, recordLinkExitFailure, runHookFast, spoolDir } from './chunk-SFFHGX3G.js';
 import './chunk-XCCLFVXM.js';
 import './chunk-BJ3KTMDH.js';
 import './chunk-VNVZDWO3.js';

package/dist/{import-capture-cmd-5NJVL2HN.js → import-capture-cmd-2BKM5I2N.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-BGWTYRSS.js';
-import './chunk-TB7EP24C.js';
-import './chunk-YT35WGIP.js';
+import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-TCIW27FM.js';
+import './chunk-2M63GG56.js';
+import './chunk-J5M7BSJQ.js';
 import './chunk-RA3O54FC.js';
 import './chunk-Z5GEFMRW.js';
 import { statSync, existsSync, readFileSync, writeFileSync } from 'fs';

package/dist/{import-ruler-cmd-TUK3MRPC.js → import-ruler-cmd-IXR7YK47.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { normalizePath } from './chunk-TB7EP24C.js';
-import './chunk-YT35WGIP.js';
+import { normalizePath } from './chunk-2M63GG56.js';
+import './chunk-J5M7BSJQ.js';
 import './chunk-Z5GEFMRW.js';
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';

package/dist/index.js

@@ -6,7 +6,7 @@ createRequire(import.meta.url);
 // src/index.ts
 var argv = process.argv.slice(2);
 if (argv[0] === "hook") {
-  const { runHookFast } = await import('./hook-fast-AQCAQIA6.js');
+  const { runHookFast } = await import('./hook-fast-PXWKQPN6.js');
   await runHookFast(argv[1]);
   process.exit(0);
 }
@@ -21,6 +21,6 @@ if (argv[0] === "statusline") {
   await runStatuslineFast(argv.slice(1));
   process.exit(0);
 }
-(await import('./hook-fast-AQCAQIA6.js')).recordLinkExitFailure(argv);
-var { runCli } = await import('./cli-RQZXTOEI.js');
+(await import('./hook-fast-PXWKQPN6.js')).recordLinkExitFailure(argv);
+var { runCli } = await import('./cli-WSBIAVZU.js');
 await runCli(process.argv);

package/dist/{init-PUY2BUHH.js → init-2LWVS4AH.js}

@@ -1,38 +1,42 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { PLACEHOLDER_MARKER, RunnerInitError, isPlaceholderCommand, readConfigObject, runRunnerInit } from './chunk-7C4T5BGN.js';
-import './chunk-BEZSECPA.js';
-import './chunk-E5DC4VZL.js';
+export { PLACEHOLDER_MARKER, RunnerInitError, isPlaceholderCommand, prepareRunnerInit, readConfigObject, runRunnerInit, writeRunnerInit } from './chunk-MJXXRX4M.js';
+import './chunk-P6FX4D43.js';
+import './chunk-MZN7AQOB.js';
+import './chunk-T5VPP6H7.js';
+import './chunk-RLYZLUQ7.js';
+import './chunk-6MZSX4M7.js';
 import './chunk-3FMPZPJQ.js';
 import './chunk-N5FOE5PS.js';
 import './chunk-OGFGZQA3.js';
-import './chunk-2GBCTEN4.js';
+import './chunk-3KTA5UU2.js';
 import './chunk-QOZKPLVJ.js';
-import './chunk-CJGQQZWB.js';
+import './chunk-NX57IBNK.js';
 import './chunk-CX22S5BA.js';
 import './chunk-QKFB4K7X.js';
 import './chunk-RSNSZ2LJ.js';
-import './chunk-DTDZXDQ3.js';
-import './chunk-ZQ5JGHUO.js';
-import './chunk-BFESLKPP.js';
-import './chunk-UES67HLJ.js';
-import './chunk-VDI5POCC.js';
-import './chunk-IU4NZROR.js';
-import './chunk-USO2DKBD.js';
+import './chunk-P4MM66C6.js';
+import './chunk-EFZLAYPE.js';
+import './chunk-IP7BIBXJ.js';
+import './chunk-4QVZCVWT.js';
+import './chunk-CNFVHDHG.js';
+import './chunk-JXYVA45C.js';
+import './chunk-4KSQKQXE.js';
 import './chunk-N6LURUEF.js';
 import './chunk-YRYMNBGQ.js';
+import './chunk-22RMZBGW.js';
 import './chunk-UXYLWVTQ.js';
 import './chunk-7RQ73DLO.js';
 import './chunk-4Q7OMKAT.js';
 import './chunk-WZBHBH3J.js';
-import './chunk-RWQWPZB4.js';
+import './chunk-GI4XXD4I.js';
 import './chunk-ZJSNLVCE.js';
-import './chunk-BMX3L7CR.js';
-import './chunk-BGWTYRSS.js';
-import './chunk-TB7EP24C.js';
+import './chunk-TCIW27FM.js';
+import './chunk-LCEXHCHD.js';
+import './chunk-2M63GG56.js';
 import './chunk-YO4PSLVB.js';
 import './chunk-PLMTLGYH.js';
-import './chunk-YT35WGIP.js';
+import './chunk-J5M7BSJQ.js';
 import './chunk-EABW6AJQ.js';
 import './chunk-BYT5O5RV.js';
 import './chunk-RA3O54FC.js';