@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-KD3SEAMV.js

@@ -0,0 +1,402 @@
+import {
+  git_pr_checks_failed
+} from "./chunk-UOVUUVDK.js";
+import {
+  api_auth
+} from "./chunk-NUR4FQHM.js";
+import {
+  RERUNS_SPENT_MESSAGE
+} from "./chunk-O7ESC4HL.js";
+import {
+  review_record_cli
+} from "./chunk-T6OUNP7E.js";
+import {
+  NO_CHECKS_MESSAGE,
+  PR_CHECKS_TIMEOUT_MESSAGE
+} from "./chunk-NRULNBYI.js";
+import {
+  UNREADABLE_COMMENTS_STOP
+} from "./chunk-5IHEBIPD.js";
+import {
+  review_finding_text
+} from "./chunk-GVDRRBHZ.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_attest
+} from "./chunk-URZ4RDC4.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  git_error
+} from "./chunk-QSBYULSS.js";
+import {
+  is_blocked_cause
+} from "./chunk-WVR4RUFP.js";
+import {
+  review_prior_findings
+} from "./chunk-ON4IKRGS.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  gh_retry
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/run/ship/run-ship-review.ts
+var LINE_SEPARATOR = /\r?\n/u;
+var HIGH = "high";
+var MEDIUM = "medium";
+var FIXED_PREFIX = "fixed ";
+var KIND_FIELDS = 2;
+var VERDICT = {
+  CLEAN: "clean",
+  FIXED: "fixed",
+  BLOCKING: "blocking",
+  INVALID: "invalid"
+};
+var MISSING_NOTE = "the reviewer wrote no findings file \u2014 the review did not complete";
+var CLEAN_NOTE = "review clean or Low-only \u2014 recorded; shipping on.";
+var FIXED_NOTE = "review fixes applied in place \u2014 recorded; the gate re-runs on the fixed tree and round 2 follows the commit.";
+var SWEEP_INSTRUCTION = [
+  "Before fixing, sweep each finding for its other sites \u2014 the same file, the callers of the same",
+  "function and a grep of the pattern \u2014 fix every site in one pass, and list each range searched on its",
+  "own line in the Issue fix comment."
+].join(" ");
+var BLOCKING_NOTE = `review found High/Medium it did not fix \u2014 recorded. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`;
+var UNVERIFIED_OUTCOME = {
+  is_passing: false,
+  note: `review fixes did not pass the scoped checks \u2014 recorded as unfixed. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`
+};
+var OTHER_SITES_CLAUSE = '"other sites: <file>:<line>, \u2026" for each other site of the same pattern';
+var ROUND_TWO_CLEAN_NOTE = "round 2 clean or Low-only \u2014 recorded; shipping on.";
+var SUBMIT_COMMAND = "pnpm josh review:submit";
+var ROUND_TWO_BLOCKING_NOTE = `round 2 found High/Medium or edited the tree \u2014 recorded; round 2 is final. ${SWEEP_INSTRUCTION} Then push and gate it, and run followup (\`chain-rule.md\` step 4).`;
+function submit_command(slot) {
+  return slot === review_attest.REVIEW_SLOT.CODE ? SUBMIT_COMMAND : `${SUBMIT_COMMAND} --interaction`;
+}
+function sink_clauses(slot, findings_path) {
+  if (findings_path !== void 0) {
+    return [
+      `Then write every finding to ${findings_path},`,
+      "and an empty file when there is none."
+    ];
+  }
+  return [
+    `Then pipe every finding on stdin to \`${submit_command(slot)}\` \u2014 never write a findings file yourself \u2014`,
+    "or run it with `--none` and no stdin when there is none; if it refuses a line, fix that line and run it again."
+  ];
+}
+function findings_instruction(slot, fixed_clause, findings_path) {
+  const categories = review_finding_ledger.CATEGORIES.join(", ");
+  const [opening, closing] = sink_clauses(slot, findings_path);
+  return [
+    opening,
+    "one per line as",
+    `<category>:<severity>:<file>[:<line>]${review_finding_text.DESCRIPTION_SEPARATOR}<one sentence: what is wrong and why>`,
+    `(category one of ${categories}; severity high, medium or low)${fixed_clause},`,
+    `a high or medium line ending with ${OTHER_SITES_CLAUSE},`,
+    closing
+  ].join(" ");
+}
+function issue_read_instruction(issue) {
+  return [
+    `Read Issue ${issue_cite.plain_for("program", issue)} with \`pnpm josh issue:read ${issue}\`, which prints the body and every`,
+    `comment together \u2014 never a body-only \`gh api \u2026/issues/${issue}\` read.`
+  ].join(" ");
+}
+var IN_SESSION_CLAUSE = "Review it yourself in this session \u2014 you carry no Skill or Agent tool, so never launch a second reviewer.";
+function round_one_opening(brief_path) {
+  return [
+    `${review_prompt_level.opening(brief_path)}Review this checkout as a /code-review: read the review brief at ${brief_path} and follow it exactly \u2014`,
+    "the level on its first line, the rubric it names, the checkout it pins and its review:attest step.",
+    IN_SESSION_CLAUSE
+  ].join(" ");
+}
+function reviewer_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    round_one_opening(brief_path),
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    "Apply a fix only for a Medium finding whose fix is small and local \u2014 a one-function refactor, an",
+    "added test, an added guard; never fix a High or a change that reaches beyond one place, and never",
+    "commit, stage or push. After any fix, run `pnpm josh lint:related && pnpm josh test:related` and",
+    "return only once both are green; revert a fix you cannot get green and report that finding unfixed.",
+    findings_instruction(
+      slot,
+      `, prefixing a finding you fixed with "${FIXED_PREFIX}"`,
+      findings_path
+    )
+  ].join(" ");
+}
+function report_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    round_one_opening(brief_path),
+    "Do not edit any file: the code review running beside this one fixes in this checkout.",
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    findings_instruction(slot, "", findings_path)
+  ].join(" ");
+}
+function slot_prompt(round_prompt, slot, slots) {
+  if (slot === review_attest.REVIEW_SLOT.CODE || slots.length === 1) return round_prompt;
+  return report_prompt;
+}
+function final_opening(brief_path) {
+  return `${round_one_opening(brief_path)} This is the final round-2 verification pass; read the scope the brief names. Do not edit any file.`;
+}
+function verification_prompt(brief_path, slot, issue, findings_path) {
+  return [
+    final_opening(brief_path),
+    issue_read_instruction(issue),
+    ...review_prior_findings.prompt_clauses(issue),
+    findings_instruction(slot, "", findings_path)
+  ].join(" ");
+}
+function finding_of(line) {
+  const is_fixed = line.startsWith(FIXED_PREFIX);
+  const unmarked = is_fixed ? line.slice(FIXED_PREFIX.length) : line;
+  return { ...review_finding_text.split_description(unmarked), is_fixed, line };
+}
+function spec_findings(text) {
+  return text.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => finding_of(line));
+}
+function is_recordable(finding) {
+  return review_record_cli.parse_finding(finding.spec) !== void 0;
+}
+function is_blocking(finding) {
+  const severity = review_record_cli.parse_finding(finding.spec)?.severity;
+  return severity === HIGH || severity === MEDIUM && !finding.is_fixed;
+}
+function kind_of(finding) {
+  return finding.spec.split(":", KIND_FIELDS).join(":");
+}
+function kinds_of(findings) {
+  return [...new Set(findings.map((finding) => kind_of(finding)))];
+}
+function stop_finding_of(finding) {
+  const location = review_record_cli.parse_finding(finding.spec)?.file ?? "";
+  return {
+    kind: kind_of(finding),
+    location,
+    sentence: review_finding_text.first_sentence(finding.description)
+  };
+}
+function deciding_findings(text) {
+  const findings = spec_findings(text).filter((finding) => is_recordable(finding));
+  const blocking = findings.filter((finding) => is_blocking(finding));
+  return blocking.length > 0 ? blocking : findings.filter((finding) => finding.is_fixed);
+}
+function blocking_kinds(text) {
+  return kinds_of(deciding_findings(text));
+}
+function blocking_details(text) {
+  return deciding_findings(text).map((finding) => stop_finding_of(finding));
+}
+function passing_fixes(verdict, outcome) {
+  if (!outcome.is_passing || verdict.kind !== VERDICT.FIXED) return [];
+  return blocking_details(verdict.report.join("\n"));
+}
+function scored_kind(findings) {
+  if (findings.some((finding) => is_blocking(finding))) return VERDICT.BLOCKING;
+  return findings.some((finding) => finding.is_fixed) ? VERDICT.FIXED : VERDICT.CLEAN;
+}
+function read_verdict(text) {
+  if (text === void 0) return { kind: VERDICT.INVALID, note: MISSING_NOTE };
+  const findings = spec_findings(text);
+  const invalid = findings.find((finding) => !is_recordable(finding));
+  if (invalid !== void 0) {
+    return { kind: VERDICT.INVALID, note: `unreadable finding: ${invalid.spec}` };
+  }
+  return {
+    kind: scored_kind(findings),
+    specs: findings.map(
+      (finding) => finding.is_fixed ? `${FIXED_PREFIX}${finding.spec}` : finding.spec
+    ),
+    report: findings.map((finding) => finding.line)
+  };
+}
+function recorded_specs(verdict, outcome) {
+  if (outcome.is_passing) return verdict.report;
+  return verdict.report.map(
+    (spec) => spec.startsWith(FIXED_PREFIX) ? spec.slice(FIXED_PREFIX.length) : spec
+  );
+}
+function round_one_outcome(verdict) {
+  if (verdict.kind === VERDICT.BLOCKING) return { is_passing: false, note: BLOCKING_NOTE };
+  return { is_passing: true, note: verdict.kind === VERDICT.FIXED ? FIXED_NOTE : CLEAN_NOTE };
+}
+function is_clean_round_one(text) {
+  return read_verdict(text).kind === VERDICT.CLEAN;
+}
+function has_fixes(text) {
+  if (text === void 0) return false;
+  return spec_findings(text).some((finding) => finding.is_fixed);
+}
+function round_two_outcome(verdict) {
+  const is_passing = verdict.kind === VERDICT.CLEAN;
+  return { is_passing, note: is_passing ? ROUND_TWO_CLEAN_NOTE : ROUND_TWO_BLOCKING_NOTE };
+}
+var run_ship_review = {
+  final_opening,
+  FIXED_PREFIX,
+  OTHER_SITES_CLAUSE,
+  SWEEP_INSTRUCTION,
+  UNVERIFIED_OUTCOME,
+  VERDICT,
+  blocking_details,
+  blocking_kinds,
+  has_fixes,
+  is_clean_round_one,
+  passing_fixes,
+  read_verdict,
+  recorded_specs,
+  report_prompt,
+  reviewer_prompt,
+  round_one_opening,
+  round_one_outcome,
+  round_two_outcome,
+  slot_prompt,
+  submit_command,
+  verification_prompt
+};
+
+// scripts/run/ship/run-ship-stop-cause.ts
+var CAUSE = {
+  FINDING: "finding",
+  INFRA: "infra",
+  CONFLICT: "conflict",
+  CHECK: "check",
+  AUTH: "auth",
+  ATTEST: "attest",
+  TIMEOUT: "timeout",
+  CI_INFRA: "ci-infra"
+};
+var { STAGE } = run_ship_stage;
+var REVIEW_STAGES = /* @__PURE__ */ new Set([STAGE.REVIEW, STAGE.ROUND_TWO]);
+var INFRA_STAGES = /* @__PURE__ */ new Set([
+  STAGE.SYNC,
+  STAGE.COMMIT,
+  STAGE.FOLLOWUP,
+  STAGE.REPORT
+]);
+var INFRA_PATTERNS = [
+  /rate limit/iu,
+  new RegExp(NO_CHECKS_MESSAGE, "u"),
+  new RegExp(UNREADABLE_COMMENTS_STOP, "u"),
+  /\b(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND)\b/u,
+  /socket hang up/iu,
+  /could not resolve host/iu,
+  /\bHTTP 50[234]\b/u
+];
+function is_infra(output) {
+  return INFRA_PATTERNS.some((pattern) => pattern.test(output));
+}
+var AUTH_LINE = new RegExp(
+  `^(?:isolated reviewer failed: (?:the broker answered a failure: )?)?${api_auth.AUTH_FAILURE_NOTE}`,
+  "mu"
+);
+function is_review(stage) {
+  return REVIEW_STAGES.has(stage);
+}
+function review_cause(output, tagged = CAUSE.FINDING) {
+  return AUTH_LINE.test(output) ? CAUSE.AUTH : tagged;
+}
+var NO_OUTPUT = { body: "" };
+function infra_text({ body, out = body }) {
+  return out;
+}
+var FAILURE_LINE = new RegExp(`^${git_error.FAILURE_PREFIX} `, "gmu");
+var REPORTED_LINE = new RegExp(
+  `^(?:${git_error.FAILURE_PREFIX}|${git_error.DETAILS_PREFIX}) (?<message>.*)$`,
+  "gmu"
+);
+function final_failures(body) {
+  const last = [...body.matchAll(FAILURE_LINE)].at(-1);
+  if (last === void 0) return [];
+  return [...body.slice(last.index).matchAll(REPORTED_LINE)].map(
+    ({ groups }) => groups?.["message"] ?? ""
+  );
+}
+function is_spent_stop(body) {
+  return final_failures(body).some((message) => body.includes(gh_retry.spent_note(message)));
+}
+function is_wait_timeout(body) {
+  return final_failures(body).includes(PR_CHECKS_TIMEOUT_MESSAGE);
+}
+function is_reruns_spent(body) {
+  return final_failures(body).some((message) => message.startsWith(RERUNS_SPENT_MESSAGE));
+}
+function ended_cause(body) {
+  if (is_wait_timeout(body)) return CAUSE.TIMEOUT;
+  return is_reruns_spent(body) ? CAUSE.CI_INFRA : void 0;
+}
+function is_infra_stop(failed) {
+  return is_infra(infra_text(failed)) || is_spent_stop(failed.body);
+}
+function stage_cause(stage, failed) {
+  if (failed.cause === CAUSE.CHECK || !INFRA_STAGES.has(stage)) return CAUSE.CHECK;
+  const ended = ended_cause(failed.body);
+  if (ended !== void 0) return ended;
+  return is_infra_stop(failed) ? CAUSE.INFRA : CAUSE.CHECK;
+}
+function cause_of(stage, failed) {
+  const { body, conflicts, cause } = failed;
+  const reason = run_ship_stage.stop_reason(stage, conflicts);
+  if (reason === run_ship_stage.CONFLICT) return CAUSE.CONFLICT;
+  if (is_review(stage)) return review_cause(body, cause);
+  return stage_cause(stage, failed);
+}
+function is_finding_stop(stage, cause) {
+  return is_review(stage) && cause === CAUSE.FINDING;
+}
+function findings_of(stage, cause, body) {
+  return is_finding_stop(stage, cause) ? run_ship_review.blocking_kinds(body) : [];
+}
+function checks_of(stage, cause, body) {
+  return stage === STAGE.FOLLOWUP && cause === CAUSE.CHECK ? git_pr_checks_failed.names_of(body) : [];
+}
+function details_of(stage, failed = NO_OUTPUT) {
+  if (!is_finding_stop(stage, cause_of(stage, failed))) return [];
+  return run_ship_review.blocking_details(failed.body);
+}
+function record_of(issue, stage, failed = NO_OUTPUT) {
+  const { body, conflicts, preconditions } = failed;
+  const cause = cause_of(stage, failed);
+  const findings = findings_of(stage, cause, body);
+  const checks = checks_of(stage, cause, body);
+  return {
+    issue,
+    reason: run_ship_stage.stop_reason(stage, conflicts),
+    cause,
+    ...preconditions !== void 0 && { preconditions: [...preconditions] },
+    ...findings.length > 0 && { findings: [...findings] },
+    ...checks.length > 0 && { checks: [...checks] }
+  };
+}
+function blocked_cause_of(body) {
+  return final_failures(body).find(is_blocked_cause);
+}
+var AT_ONCE_CAUSES = /* @__PURE__ */ new Set([CAUSE.TIMEOUT, CAUSE.CI_INFRA]);
+function parks_at_once(stage, failed) {
+  return AT_ONCE_CAUSES.has(cause_of(stage, failed));
+}
+var run_ship_stop_cause = {
+  CAUSE,
+  blocked_cause_of,
+  cause_of,
+  details_of,
+  is_review,
+  parks_at_once,
+  record_of
+};
+
+export {
+  run_ship_review,
+  run_ship_stop_cause
+};

package/dist/commands/chunk-KDCHY7XO.js

@@ -0,0 +1,88 @@
+import {
+  bash_triggers
+} from "./chunk-2BC33QPY.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  agent_consultation_model
+} from "./chunk-O5JGV7NA.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/main-model.ts
+import { z } from "zod";
+var SYNTHETIC_MODEL = "<synthetic>";
+var named_model = z.object({ model: z.string() });
+var entry_schema = z.union([
+  z.object({ type: z.literal("assistant"), message: named_model }),
+  z.object({ type: z.literal("turn_context"), payload: named_model })
+]);
+function model_of_line(line) {
+  const entry = json_value.parse_with(line, entry_schema);
+  if (entry === void 0) return void 0;
+  const model = entry.type === "assistant" ? entry.message.model : entry.payload.model;
+  return model === SYNTHETIC_MODEL ? void 0 : model;
+}
+function model_of_tail(tail) {
+  const lines = tail.split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const model = model_of_line(lines[index] ?? "");
+    if (model !== void 0) return model;
+  }
+  return void 0;
+}
+function main_model(tail, payload_model, recorded_model) {
+  return payload_model ?? model_of_tail(tail) ?? recorded_model;
+}
+var main_model_reader = { main_model };
+
+// scripts/rules/consultation-handoff.ts
+var HANDOFF_DOC = '`docs/josh-commands-board.md` \u2192 "josh run:handoff"';
+var REASON = `\u26D4 consultation handoff: a consultation-model main line does not enter a run itself. Run \`pnpm josh run:handoff <keyword> \u2026 --brief-file <brief>\` instead of \`run:entry\` / \`run:hold\`; filing and operating (\`issue:file\`, \`issue:plan\`, \`epic\`) stay here. Fires on every occurrence (${HANDOFF_DOC}).`;
+function josh_call_of(names) {
+  const name_set = new Set(names);
+  return function is_josh_call(command) {
+    return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, name_set));
+  };
+}
+var is_entry_call = josh_call_of(["run:entry", "run:hold"]);
+var is_handoff_call = josh_call_of(["run:handoff"]);
+function is_consultation_main(tail, payload_model, recorded_model) {
+  const model = main_model_reader.main_model(tail, payload_model, recorded_model);
+  return model !== void 0 && agent_consultation_model.consultation_provider(model) !== void 0;
+}
+function is_not_consultation_main(tail, _call, run) {
+  if (lane_child_marker.is_child_of(run.context.cwd, run.context.env)) return true;
+  return run.is_unit === true || !is_consultation_main(tail, run.model);
+}
+var ROW = {
+  id: "consultation-handoff",
+  is_trigger: bash_triggers.on_bash_command(is_entry_call),
+  reason: REASON,
+  already_satisfied: is_not_consultation_main,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(is_handoff_call),
+  about: {
+    title: "Consultation main line hands a run to run:handoff",
+    topic: HANDOFF_DOC,
+    fires: "`pnpm josh run:entry` / `run:hold` on Fable or Codex Astra. Every occurrence",
+    quiet: "a lane child, a main line on any other model, an unnamed model, a delegated unit, or filing and operating (`issue:file`, `issue:plan`, `epic`)"
+  }
+};
+var consultation_handoff = {
+  HANDOFF_DOC,
+  ROW,
+  is_consultation_main,
+  is_entry_call,
+  is_handoff_call
+};
+
+export {
+  main_model_reader,
+  consultation_handoff
+};

package/dist/commands/chunk-KDGX3JTV.js

@@ -0,0 +1,51 @@
+import {
+  observation_ledger_home,
+  observation_ledger_line
+} from "./chunk-QXBOECGL.js";
+
+// scripts/observations/observation-record.ts
+var FILE_VERDICT = "file";
+var LEDGER_VERDICT = "ledger";
+var REFUSED_VERDICT = "refused";
+var RESERVED_SLUG = "example";
+var RESERVED_REASON = "`k:example` is reserved for the sample in observation-ledger.md";
+var PROMOTING_COUNT = 1;
+function collapsed(field) {
+  return field.replaceAll(/\s+/gu, " ").trim();
+}
+function entry_line(entry, date) {
+  return `- k:${entry.slug} | ${entry.depth} | ${date} | ${collapsed(entry.where)} | ${collapsed(entry.what)}`;
+}
+function refusal_of(entry, line) {
+  if (entry.slug === RESERVED_SLUG) return RESERVED_REASON;
+  return observation_ledger_line.line_reason(line);
+}
+function sightings(ledger, slug) {
+  const prefix = `- k:${slug} |`;
+  return (ledger ?? "").split("\n").filter((line) => line.startsWith(prefix));
+}
+async function assess(request) {
+  const date = observation_ledger_home.ledger_date(request.now);
+  const line = entry_line(request.entry, date);
+  const reason = refusal_of(request.entry, line);
+  if (reason !== void 0) return { verdict: REFUSED_VERDICT, reason };
+  const earlier = sightings(
+    await observation_ledger_home.read(request.checkout),
+    request.entry.slug
+  );
+  const verdict = earlier.length === PROMOTING_COUNT ? FILE_VERDICT : LEDGER_VERDICT;
+  return { verdict, earlier, line };
+}
+async function record(request) {
+  const assessment = await assess(request);
+  if (assessment.verdict === REFUSED_VERDICT) return assessment;
+  const target = await observation_ledger_home.writer_path(request.now, request.checkout);
+  await observation_ledger_home.append(target, [assessment.line]);
+  return { ...assessment, target };
+}
+var observation_record = { assess, record };
+
+export {
+  REFUSED_VERDICT,
+  observation_record
+};