@joshuafolkken/kit 1.1035.0 → 1.1050.0

package/dist/version/index.js

@@ -151,7 +151,7 @@ function resolve_effective_upstream_version(base_url, package_name, options = {}
 }
 
 // scripts/version/version-commands.ts
-import { execaSync as execaSync3 } from "execa";
+import { execaSync as execaSync4 } from "execa";
 
 // scripts/version/release-age.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -808,6 +808,373 @@ var git_gh_exec = {
   parse_status_line
 };
 
+// scripts/gh/fix-gh-packages-logic.ts
+import { loadAll } from "js-yaml";
+import { z as z4 } from "zod";
+var GH_PACKAGES_HOST = "npm.pkg.github.com";
+var RESOLUTION_BLOCK = "\n    resolution:\n";
+var INTEGRITY_PREFIX = "      integrity: ";
+var TARBALL_PREFIX = "      tarball: ";
+var FLOW_RESOLUTION_LINE_START = "\n    resolution: {";
+var FLOW_TARBALL_KEY = ", tarball: ";
+var NPMRC_AUTH_TOKEN_PREFIX = `//${GH_PACKAGES_HOST}/:_authToken=`;
+var REGISTRY_KEY = ":registry=";
+var lockfile_resolution_schema = z4.looseObject({
+  integrity: z4.string().optional(),
+  tarball: z4.string().optional()
+});
+var lockfile_package_schema = z4.looseObject({
+  resolution: lockfile_resolution_schema.optional()
+});
+var lockfile_document_schema = z4.looseObject({
+  packages: z4.record(z4.string(), lockfile_package_schema).optional()
+});
+function parse_lockfile_packages(raw) {
+  const merged = {};
+  for (const document of loadAll(raw)) {
+    const { packages } = lockfile_document_schema.parse(document);
+    if (packages !== void 0) Object.assign(merged, packages);
+  }
+  return merged;
+}
+function extract_gh_registry_scope(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("@")) return void 0;
+  const eq_index = trimmed.indexOf(REGISTRY_KEY);
+  if (eq_index === -1) return void 0;
+  const registry = trimmed.slice(eq_index + REGISTRY_KEY.length).trim().replace(/\/$/u, "");
+  if (registry !== `https://${GH_PACKAGES_HOST}`) return void 0;
+  return trimmed.slice(0, eq_index);
+}
+function parse_gh_scopes(npmrc) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const line of npmrc.split("\n")) {
+    const scope = extract_gh_registry_scope(line);
+    if (scope !== void 0) scopes.add(scope);
+  }
+  return scopes;
+}
+function extract_auth_token_from_line(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(NPMRC_AUTH_TOKEN_PREFIX)) return void 0;
+  const value = trimmed.slice(NPMRC_AUTH_TOKEN_PREFIX.length);
+  if (value.startsWith("${") || value.length === 0) return void 0;
+  return value;
+}
+function parse_npmrc_auth_token(npmrc) {
+  for (const line of npmrc.split("\n")) {
+    const token = extract_auth_token_from_line(line);
+    if (token !== void 0) return token;
+  }
+  return void 0;
+}
+function scope_from_key(key) {
+  return key.startsWith("@") ? key.split("/", 1)[0] ?? "" : "";
+}
+function has_tarball(entry) {
+  return entry.resolution?.tarball !== void 0;
+}
+function package_path_from_key(key) {
+  const start = key.startsWith("@") ? 1 : 0;
+  const at_index = key.indexOf("@", start);
+  return at_index === -1 ? key : key.slice(0, at_index);
+}
+function package_version_from_key(key) {
+  const start = key.startsWith("@") ? 1 : 0;
+  const at_index = key.indexOf("@", start);
+  if (at_index === -1) return "";
+  return key.slice(at_index + 1).split("(", 1)[0] ?? "";
+}
+function should_fix_tarball(key, entry, scopes) {
+  if (has_tarball(entry)) return false;
+  const scope = scope_from_key(key);
+  return scope.length > 0 && scopes.has(scope);
+}
+function find_entry_start(content, package_key) {
+  const single = content.indexOf(`
+  '${package_key}':
+`);
+  if (single !== -1) return single;
+  return content.indexOf(`
+  "${package_key}":
+`);
+}
+function find_entry_end(content, entry_start) {
+  const next_match = /\n {2}['"]/u.exec(content.slice(entry_start + 1));
+  return next_match === null ? content.length : entry_start + 1 + next_match.index;
+}
+function find_integrity_eol_in_entry(entry_content) {
+  const resolution_pos = entry_content.indexOf(RESOLUTION_BLOCK);
+  if (resolution_pos === -1) return -1;
+  const integrity_pos = entry_content.indexOf(INTEGRITY_PREFIX, resolution_pos);
+  if (integrity_pos === -1) return -1;
+  return entry_content.indexOf("\n", integrity_pos);
+}
+function find_flow_resolution_brace(entry_content) {
+  const pos = entry_content.indexOf(FLOW_RESOLUTION_LINE_START);
+  if (pos === -1) return -1;
+  const line_end = entry_content.indexOf("\n", pos + 1);
+  const search_end = line_end === -1 ? entry_content.length : line_end;
+  const brace = entry_content.lastIndexOf("}", search_end);
+  if (brace <= pos) return -1;
+  return brace;
+}
+function insert_expanded_tarball(content, entry_start, entry_end, tarball) {
+  const entry_content = content.slice(entry_start, entry_end);
+  const integrity_eol = find_integrity_eol_in_entry(entry_content);
+  if (integrity_eol === -1) return void 0;
+  if (entry_content.slice(integrity_eol + 1).startsWith(TARBALL_PREFIX)) return content;
+  const patched = `${entry_content.slice(0, integrity_eol + 1)}${TARBALL_PREFIX}${tarball}
+${entry_content.slice(integrity_eol + 1)}`;
+  return content.slice(0, entry_start) + patched + content.slice(entry_end);
+}
+function insert_flow_tarball(content, entry_start, entry_end, tarball) {
+  const entry_content = content.slice(entry_start, entry_end);
+  const brace_pos = find_flow_resolution_brace(entry_content);
+  if (brace_pos === -1) return void 0;
+  const open_brace = entry_content.lastIndexOf("{", brace_pos);
+  if (open_brace === -1) return void 0;
+  const flow_body = entry_content.slice(open_brace + 1, brace_pos);
+  if (/\btarball\s*:/u.test(flow_body)) return content;
+  const patched = `${entry_content.slice(0, brace_pos)}${FLOW_TARBALL_KEY}${tarball}${entry_content.slice(brace_pos)}`;
+  return content.slice(0, entry_start) + patched + content.slice(entry_end);
+}
+function insert_tarball_for_key(content, package_key, tarball) {
+  const entry_start = find_entry_start(content, package_key);
+  if (entry_start === -1) return content;
+  const entry_end = find_entry_end(content, entry_start);
+  return insert_expanded_tarball(content, entry_start, entry_end, tarball) ?? insert_flow_tarball(content, entry_start, entry_end, tarball) ?? content;
+}
+function patch_lockfile(content, patches) {
+  let result = content;
+  for (const [key, tarball] of patches) {
+    result = insert_tarball_for_key(result, key, tarball);
+  }
+  return result;
+}
+function resolve_token(environment_token, npmrc_token, get_fallback_token) {
+  if (environment_token !== void 0 && environment_token.length > 0) return environment_token;
+  if (npmrc_token !== void 0) return npmrc_token;
+  return get_fallback_token();
+}
+var fix_gh_packages_logic = {
+  parse_gh_scopes,
+  parse_npmrc_auth_token,
+  parse_lockfile_packages,
+  package_path_from_key,
+  package_version_from_key,
+  needs_tarball_fix: should_fix_tarball,
+  insert_tarball_for_key,
+  patch_lockfile,
+  resolve_token
+};
+
+// scripts/registry-migration/migrate-logic.ts
+var SCOPE = "@joshuafolkken";
+var REGISTRY_KEY2 = `${SCOPE}:registry`;
+var PUBLIC_REGISTRY = "https://registry.npmjs.org/";
+var GITHUB_REGISTRY = "https://npm.pkg.github.com/";
+var MAPPING = `${REGISTRY_KEY2}=${PUBLIC_REGISTRY}`;
+var REGISTRY_VALUE_INDEX = 1;
+var SPLIT_LIMIT = 2;
+function normalized_registry(value) {
+  let normalized = value.trim();
+  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return `${normalized}/`;
+}
+function mapping_lines(content) {
+  return content.split(/\r?\n/u).filter((line) => line.trimStart().startsWith(`${REGISTRY_KEY2}=`));
+}
+function registry_of(content) {
+  const lines = mapping_lines(content);
+  if (lines.length !== 1) return void 0;
+  return normalized_registry(lines[0]?.split("=", SPLIT_LIMIT)[REGISTRY_VALUE_INDEX] ?? "");
+}
+function scoped_packages(lockfile) {
+  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
+  return Object.keys(packages).filter((key) => key.startsWith(`${SCOPE}/`)).map((key) => fix_gh_packages_logic.package_path_from_key(key)).filter((name, index, names) => names.indexOf(name) === index);
+}
+function scoped_versions(lockfile) {
+  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
+  return Object.keys(packages).filter((key) => key.startsWith(`${SCOPE}/`)).map(
+    (key) => [
+      fix_gh_packages_logic.package_path_from_key(key),
+      fix_gh_packages_logic.package_version_from_key(key)
+    ]
+  );
+}
+function is_github_tarball(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname === "npm.pkg.github.com";
+  } catch {
+    return false;
+  }
+}
+function github_tarballs(lockfile) {
+  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
+  return Object.entries(packages).filter(
+    ([key, entry]) => key.startsWith(`${SCOPE}/`) && entry.resolution?.tarball !== void 0 && is_github_tarball(entry.resolution.tarball)
+  ).map(([key]) => key);
+}
+function remove_flow_tarball(line) {
+  const marker = ", tarball: https://npm.pkg.github.com/";
+  const start = line.indexOf(marker);
+  if (start === -1) return line;
+  const end = line.indexOf("}", start);
+  if (end === -1) return line;
+  return `${line.slice(0, start)}${line.slice(end)}`;
+}
+function is_package_entry(line) {
+  return /^ {2}[^ ]/u.test(line);
+}
+function is_github_tarball_line(line) {
+  return line.trimStart().startsWith("tarball: https://npm.pkg.github.com/");
+}
+function clean_kit_line(line, version, integrities) {
+  if (!version) return line;
+  if (is_github_tarball_line(line)) return void 0;
+  const cleaned = remove_flow_tarball(line);
+  const pair = integrities.get(version);
+  if (pair === void 0) return cleaned;
+  return cleaned.split(`integrity: ${pair[0]}`).join(`integrity: ${pair[1]}`);
+}
+function next_kit_version(line, version) {
+  if (!is_package_entry(line)) return version;
+  const prefix = "  '@joshuafolkken/kit@";
+  return line.startsWith(prefix) ? line.slice(prefix.length).split("'", 1)[0] ?? "" : "";
+}
+function integrity_pair(old_integrity, npm_integrity) {
+  if (old_integrity === void 0 || npm_integrity === void 0) return void 0;
+  return [old_integrity, npm_integrity];
+}
+function lock_integrities(lockfile, npm_integrities) {
+  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
+  const pairs = /* @__PURE__ */ new Map();
+  const kit_entries = Object.entries(packages).filter(([key]) => key.startsWith(`${SCOPE}/kit@`));
+  for (const [key, entry] of kit_entries) {
+    const version = fix_gh_packages_logic.package_version_from_key(key);
+    const pair = integrity_pair(entry.resolution?.integrity, npm_integrities.get(version));
+    if (pair !== void 0) pairs.set(version, pair);
+  }
+  return pairs;
+}
+function push_if_defined(lines, cleaned) {
+  if (cleaned !== void 0) lines.push(cleaned);
+}
+function rewrite_kit_lockfile(lockfile, npm_integrities) {
+  let kit_version = "";
+  const lines = [];
+  const integrities = lock_integrities(lockfile, npm_integrities);
+  for (const line of lockfile.split("\n")) {
+    kit_version = next_kit_version(line, kit_version);
+    const cleaned = clean_kit_line(line, kit_version, integrities);
+    push_if_defined(lines, cleaned);
+  }
+  return lines.join("\n");
+}
+function append_mapping(content, eol) {
+  const separator = content && !content.endsWith("\n") ? eol : "";
+  return `${content}${separator}${MAPPING}${eol}`;
+}
+function replace_mapping(content) {
+  const lines = mapping_lines(content);
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  if (lines.length === 0) return append_mapping(content, eol);
+  return content.split(/\r?\n/u).map((line) => line === lines[0] ? MAPPING : line).join(eol);
+}
+function unsupported_registry(project_npmrc) {
+  const registry = registry_of(project_npmrc);
+  if (registry === void 0 || [GITHUB_REGISTRY, PUBLIC_REGISTRY].includes(registry)) {
+    return void 0;
+  }
+  return `unsupported project registry: ${registry}`;
+}
+function has_duplicate_mapping(project_npmrc, user_npmrc) {
+  return mapping_lines(project_npmrc).length > 1 || mapping_lines(user_npmrc).length > 1;
+}
+function previous_registry(project_npmrc, user_npmrc) {
+  return registry_of(project_npmrc) ?? registry_of(user_npmrc) ?? "default npm";
+}
+function plan(project_npmrc, user_npmrc, lockfile) {
+  const packages = scoped_packages(lockfile);
+  const blocked = packages.filter((name) => name !== `${SCOPE}/kit`);
+  if (has_duplicate_mapping(project_npmrc, user_npmrc)) blocked.push("duplicate registry mappings");
+  const unsupported = unsupported_registry(project_npmrc);
+  if (unsupported !== void 0) blocked.push(unsupported);
+  const before = previous_registry(project_npmrc, user_npmrc);
+  const change = `${before} \u2192 ${PUBLIC_REGISTRY}`;
+  return { content: replace_mapping(project_npmrc), packages, blocked, change };
+}
+var migrate_logic = {
+  plan,
+  github_tarballs,
+  is_github_tarball,
+  rewrite_kit_lockfile,
+  registry_of,
+  scoped_packages,
+  scoped_versions
+};
+
+// scripts/version/npm-registry.ts
+import { execaSync as execaSync2 } from "execa";
+import { z as z5 } from "zod";
+var PUBLIC_REGISTRY2 = "https://registry.npmjs.org";
+var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
+var FULL_ACCEPT = "application/json";
+var REQUEST_TIMEOUT_MS = 1e4;
+var SCOPE_SEPARATOR = "/";
+var ENCODED_SCOPE_SEPARATOR = "%2f";
+var SCOPE_PATTERN = /^@[^/]+(?=\/)/u;
+var SCOPE_REGISTRY_SUFFIX = ":registry";
+var github_scopes = /* @__PURE__ */ new Map();
+var FETCH_SCRIPT = [
+  "const [url, accept] = process.argv.slice(1)",
+  "const response = await fetch(url, { headers: { accept } })",
+  "if (!response.ok) process.exit(1)",
+  "process.stdout.write(await response.text())"
+].join("\n");
+var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: z5.string() }) });
+var times_schema = z5.looseObject({ time: release_age.release_times_schema });
+function packument_url(package_name) {
+  return `${PUBLIC_REGISTRY2}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
+}
+function read_packument(package_name, accept) {
+  const result = execaSync2(
+    process.execPath,
+    ["--input-type=module", "-e", FETCH_SCRIPT, packument_url(package_name), accept],
+    { reject: false, timeout: REQUEST_TIMEOUT_MS }
+  );
+  if (result.exitCode !== 0) return void 0;
+  return safe_json_parse(result.stdout);
+}
+function is_github_scope(scope) {
+  const is_cached_github = github_scopes.get(scope);
+  if (is_cached_github !== void 0) return is_cached_github;
+  const result = execaSync2("pnpm", ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
+    reject: false,
+    timeout: REQUEST_TIMEOUT_MS
+  });
+  const is_github = result.exitCode === 0 && migrate_logic.is_github_tarball(result.stdout.trim());
+  github_scopes.set(scope, is_github);
+  return is_github;
+}
+function is_public_source(package_name) {
+  const scope = SCOPE_PATTERN.exec(package_name)?.[0];
+  return scope === void 0 || !is_github_scope(scope);
+}
+function read_latest(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = latest_schema.safeParse(read_packument(package_name, ABBREVIATED_ACCEPT));
+  return parsed.success ? parsed.data["dist-tags"].latest : void 0;
+}
+function read_release_times(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
+  return parsed.success ? parsed.data.time : void 0;
+}
+var npm_registry = { packument_url, read_latest, read_release_times };
+
 // scripts/version/version-remote.ts
 var TIMES_PAGE_SIZE = 100;
 var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
@@ -819,6 +1186,8 @@ function require_endpoint(versions_endpoint, package_name) {
 }
 function fetch_latest_version(versions_endpoint, package_name) {
   const endpoint = require_endpoint(versions_endpoint, package_name);
+  const public_latest = npm_registry.read_latest(package_name);
+  if (public_latest !== void 0) return public_latest;
   try {
     return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
   } catch (error) {
@@ -838,14 +1207,17 @@ function with_page_size(endpoint, page_size) {
   query.set("per_page", String(page_size));
   return `${path_part}?${query.toString()}`;
 }
-function fetch_release_times(versions_endpoint) {
-  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+function read_github_release_times(versions_endpoint) {
   const endpoint = with_page_size(versions_endpoint, TIMES_PAGE_SIZE);
   const stdout = git_gh_exec.read_gh_api_sync({ path: endpoint, jq_filter: TIMES_JQ });
   if (stdout === void 0) return void 0;
   const parsed = release_age.release_times_schema.safeParse(safe_json_parse(stdout));
   return parsed.success ? parsed.data : void 0;
 }
+function fetch_release_times(versions_endpoint, package_name) {
+  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+  return npm_registry.read_release_times(package_name) ?? read_github_release_times(versions_endpoint);
+}
 
 // scripts/version/version-targets.ts
 import path4 from "node:path";
@@ -877,7 +1249,7 @@ function read_if_readable(path5) {
 var file_reader = { read_optional, read_file_or_empty, read_if_readable };
 
 // scripts/version/version-targets.ts
-import { execaSync as execaSync2 } from "execa";
+import { execaSync as execaSync3 } from "execa";
 var NODE_MODULES2 = "node_modules";
 var PACKAGE_JSON3 = "package.json";
 function build_pnpm_ls_arguments(package_name) {
@@ -894,7 +1266,7 @@ function parse_project_version(raw) {
   return parsed.success ? parsed.data.version : void 0;
 }
 function read_global_version(package_name) {
-  const result = execaSync2("pnpm", build_pnpm_ls_arguments(package_name), { reject: false });
+  const result = execaSync3("pnpm", build_pnpm_ls_arguments(package_name), { reject: false });
   return parse_global_version(result.stdout, package_name);
 }
 function project_package_path(cwd, package_name) {
@@ -928,12 +1300,12 @@ var version_targets = {
 var FAILURE_EXIT_CODE = 1;
 var ALREADY_UP_TO_DATE = "Already up to date";
 var NO_QUARANTINE_MINUTES2 = 0;
-function read_release_hold(versions_endpoint, latest, versions) {
+function read_release_hold(package_config, latest, versions) {
   if (versions.every((version) => version === void 0 || version === latest)) return void 0;
   const minimum_age_minutes = release_age.read_nearest_minimum_release_age(process.cwd());
   if (minimum_age_minutes <= NO_QUARANTINE_MINUTES2) return void 0;
   const installable = release_hold.resolve_installable(
-    fetch_release_times(versions_endpoint),
+    fetch_release_times(package_config.versions_endpoint, package_config.package_name),
     latest,
     minimum_age_minutes,
     Date.now()
@@ -990,7 +1362,7 @@ function read_upstream_report(upstream, config, snapshot, is_hold_wanted) {
   const project_version = version_targets.read_project_version(process.cwd(), upstream.package_name);
   const report = { config: upstream, project_version, latest };
   attach_upstream_effective(report, config, snapshot, upstream);
-  const hold = is_hold_wanted ? read_release_hold(upstream.versions_endpoint, latest, [report.effective?.version]) : void 0;
+  const hold = is_hold_wanted ? read_release_hold(upstream, latest, [report.effective?.version]) : void 0;
   if (hold !== void 0) report.hold = hold;
   return report;
 }
@@ -1012,7 +1384,7 @@ function run_check(config) {
   );
 }
 function run_upgrade_command(command) {
-  const result = execaSync3("sh", ["-c", command], { stdio: "inherit", reject: false });
+  const result = execaSync4("sh", ["-c", command], { stdio: "inherit", reject: false });
   return result.exitCode ?? FAILURE_EXIT_CODE;
 }
 function run_all_upgrade_commands(commands) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1035.0",
+  "version": "1.1050.0",
   "name": "@joshuafolkken/kit",
   "description": "Development toolkit for AI-assisted projects: formatting, AI assistant rules and a Git/GitHub Issue workflow for any repository, plus lint, type check, tests and hooks for Node projects",
   "keywords": [
@@ -221,7 +221,7 @@
     "@playwright/test": "^1.63.0",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.6",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "@types/node": "^26.6.3",
+    "@types/node": "^26.6.4",
     "@types/semver": "^7.8.0",
     "cspell": "^10.3.6",
     "esbuild": "^0.28.2",
@@ -233,17 +233,17 @@
     "eslint-plugin-sonarjs": "^4.2.2",
     "eslint-plugin-unicorn": "^76.0.0",
     "eslint_d": "^15.0.3",
-    "globals": "^17.12.0",
-    "lefthook": "^2.1.15",
+    "globals": "^17.13.0",
+    "lefthook": "^2.1.16",
     "prettier": "^3.9.9",
     "prettier-plugin-svelte": "^4.1.1",
     "prettier-plugin-tailwindcss": "^0.8.1",
-    "rollup": "^4.63.5",
+    "rollup": "^4.63.6",
     "rollup-plugin-dts": "^6.5.1",
     "secretlint": "^13.0.6",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.71.0",
-    "vitest": "^5.0.2"
+    "vitest": "^5.0.3"
   },
   "dependencies": {
     "execa": "^10.0.1",

package/prompts/collaboration-workflow/file-edits.md

@@ -2,6 +2,8 @@
 
 `CLAUDE.md` →「Never carry a file's new text inside a shell command.」の正典。
 
+`pnpm josh rule:guard`（file-body の行）が、既存ファイルを書き戻すヒアドキュメント・書き込みを伴うインタプリタ heredoc / `node -e`・in-place `perl -0pi -e` をその呼び出しで拒否し、規則を述べる。**このファイルが担うのはガードに見えないもの**である — Bash を通らない Edit / Write の全文書き直し、ガードを素通りする `sed -i` の 4 条件、そしてコストである。
+
 ### 何を禁じているか
 
 **編集後のテキストを丸ごとコマンド行に載せる形を禁じる。** 典型は、インタプリタを起動して領域を書き戻す次の形である。
@@ -40,14 +42,7 @@ PY
 
 **レビュー指摘の修正がこの規則の主戦場である。** 「この行の条件が逆」「この定数を切り出す」といった局所的な指摘ほど、部分編集は小さくなる。一方で全文書き直しのコストはファイルの大きさで決まり、指摘の小ささでは下がらない。**指摘が局所的であるほど、全文書き直しとの差は開く。**
 
-joshuafolkken/kit#1251 のランで実測した値（joshuafolkken/kit#1260）:
-
-| ターン             | 出力トークン | 内容                                                     |
-| ------------------ | ------------ | -------------------------------------------------------- |
-| レビュー指摘の修正 | 11,104       | 2 ファイルの全文書き直し。そのランの単一ターンとして最大 |
-| 同じランの別ターン | 3,282        | 全文書き直し                                             |
-
-実効生成速度は約 87 トークン/秒なので、**この 1 ランで約 2 分 45 秒が、すでに存在する行を打ち直すことに使われている。**
+実測では 1 ランで約 2 分 45 秒が、すでに存在する行を打ち直すことに使われていた（joshuafolkken/kit#1260）。内訳は `docs/maintainers/file-edits-rationale.md` → "全文書き直しの実測"。
 
 ### `sed -i` を使う前に満たす 4 条件
 
@@ -71,54 +66,12 @@ joshuafolkken/kit#1251 のランで実測した値（joshuafolkken/kit#1260）:
 
 ### なぜコストが二重になるか
 
-インタプリタで書き戻す形は、編集後の本文が**コマンド本文とファイルの両方**に載る。さらに悪いのは持続性である。**コマンド本文は、書いた時点以降のすべてのリクエストで読み直される。** ランの序盤に書いた編集スクリプトほど、そのランの残り全リクエストぶん課金され続ける。ファイル側は次に読んだときだけ載るのに対し、コマンド側は消えない。
-
-joshuafolkken/kit#1144 のランのトランスクリプトで実測した内訳（joshuafolkken/kit#1150）:
-
-| 種別                    | 割合      |
-| ----------------------- | --------- |
-| tool_result             | 37.7%     |
-| **Bash のコマンド本文** | **30.2%** |
-| thinking                | 24.9%     |
-| text                    | 4.7%      |
-
-Bash コマンド本文 97,042 tok・427 呼び出しの内訳:
-
-| 種別                                  | 呼び出し数 | トークン   | 割合      |
-| ------------------------------------- | ---------- | ---------- | --------- |
-| `python3 - <<'PY'` 形式のファイル編集 | 145        | **79,317** | **81.7%** |
-| git / gh / pnpm                       | 140        | 12,716     | 13.1%     |
-| 読み取り・検索                        | 110        | 3,215      | 3.3%      |
-| その他                                | 32         | 1,794      | 1.8%      |
-
-**編集スクリプトだけでセッション全体のコンテキストの約 2 割を占めていた。** 1 回あたり平均 547 tok、上位は 1,200〜1,800 tok。総量そのものより、二重計上と持続が効いている。
-
-適用後の再計測は joshuafolkken/kit#1159 が担当する。
+インタプリタで書き戻す形は、編集後の本文が**コマンド本文とファイルの両方**に載る。さらに悪いのは持続性である。**コマンド本文は、書いた時点以降のすべてのリクエストで読み直される。** ランの序盤に書いた編集スクリプトほど、そのランの残り全リクエストぶん課金され続ける。ファイル側は次に読んだときだけ載るのに対し、コマンド側は消えない。実測の内訳は `docs/maintainers/file-edits-rationale.md` → "コマンド本文の実測内訳"。
 
 ### なぜ resident に置くか
 
-residency 基準（`residency.md`）は 1 問で決まる。
-
-> **その規則は、skill がロードされていないターンでも効く必要があるか。**
-
-答えは yes である。ファイル編集はワークフローのキーワードが打たれていないターンでも起き、**編集の直前にロードされる skill は存在しない。** skill 側に本体を置いた場合、この規則は一度も発火しない — 規則を書いたのに削除したのと同じ振る舞いになる。
-
-そのうえで、常駐側に置くのは**トリガと導線だけ**である。常駐側に残すのは次の 3 点で、それだけで正しく振る舞える。
-
-1. 領域を指定する編集は Edit で行い、インタプリタや heredoc で領域を書き戻さない
-2. **Edit 自体を全文へ広げない**（joshuafolkken/kit#1260）
-3. 判断基準は「本文を丸ごと運ぶか」であってツール名ではない（短い `sed -i` は許される）
-
-実測値・可否表・二重計上の説明・全文書き直しが許される 3 条件、そして**インタプリタの具体形**（`python3 - <<'PY'` / `node -e` / `cat > file <<'EOF'`）はこのファイルにあり、常駐側からは落としている。これらは「読まなくても正しく振る舞えるが、読めばより納得できる」種類の記述だからである。**具体形を指し先へ移したのは削除ではなく移動である** — 禁止の区分は常駐側の「インタプリタや heredoc」が担い、個々の形はこのファイルの可否表が担う。
+根拠は `docs/maintainers/file-edits-rationale.md` → "なぜ resident に置くか"。
 
 ### マーカーテスト
 
-`scripts/document/document-markers.test.ts` が次を固定する。
-
-- `CLAUDE.md` に規則のトリガ文と判断基準の一文が resident で存在すること
-- `CLAUDE.md` に全文書き直しの禁止（「Edit を全文へ広げない」）が resident で存在すること
-- 常駐側がこのファイルを導線として指していること
-- このファイルが判断基準・可否表・`sed -i` の 4 条件・全文書き直しの 3 条件を持っていること
-- インタプリタの具体形 3 つ（`python3 - <<'PY'` / `node -e` / `cat > file <<'EOF'`）が常駐側にも residency 一覧にも残っておらず、このファイルにあること
-- 実測値（79,317 / 81.7% / 30.2% / 11,104 / 3,282）が常駐側にも residency 一覧にも貼り戻されていないこと
-- residency の一覧（`.claude/skills/workflow-commands/SKILL.md` とこのディレクトリの `residency.md`）にこの規則が載っていること
+固定している内容は `docs/maintainers/file-edits-rationale.md` → "マーカーテスト"。

package/prompts/collaboration-workflow/residency.md

@@ -77,7 +77,7 @@
 - **UI 検証ゲート** — 画面に出る変更は、実際にレンダリング結果を見るまで完了ではない。撮影の手順は `verify-ui` にある。このゲートが効くのは UI 変更の完了を報告する瞬間であり、ワークフローのキーワードが打たれておらず skill が何もロードされていないターンであることが多い
 - **レビュー上限後の後追い起票の手順** — 起票して `epic:bundle` で EPIC へ繋ぎ直すところまで。コミット前セルフレビューはワークフローの外でも回るので、そこで起票された Issue も同じように孤児になる。完全な手順は `prompts/review.md` →「Review round cap」にある（joshuafolkken/kit#946）
 - **`josh epic:*` のうちコマンドの外側で効く 3 件** — 決定の記録による `needs-decision` の解除、`epic:audit` の指摘を直すのが Tier A であること、別リポジトリの EPIC を `owner/repo#N` で参照すること。いずれも `epic:*` コマンドを走らせていないターン（Issue を起票した直後、決定を書いた瞬間）に効く。コマンド自身の手順は `.claude/skills/epic-commands/` にある
-- **編集後の本文をコマンドに載せない禁止** — ファイル編集はどのターンでも起き、**編集の直前にロードされる skill は存在しない**。オンデマンド側に置くとこの規則は一度も発火せず、書いたのに削除したのと同じ振る舞いになる。実測値・可否表・根拠は [`file-edits.md`](./file-edits.md) にあり、常駐に残すのは指示と判断基準（「本文を丸ごと運ぶか」であってツール名ではない）だけである（joshuafolkken/kit#1150）。**Edit 自体を全文へ広げる形も同じ規則の一部である** — 数行の指摘に対する全文書き直しは、ツールを替えただけで同じコストを払っている。常駐にはその禁止の一句だけを置き、全文を書いてよい 3 条件は同じ指し先にある（joshuafolkken/kit#1260）
+- **編集後の本文をコマンドに載せない禁止** — ファイル編集はどのターンでも起き、**編集の直前にロードされる skill は存在しない**。オンデマンド側に置くとこの規則は一度も発火せず、書いたのに削除したのと同じ振る舞いになる。可否表は [`file-edits.md`](./file-edits.md)、実測値と根拠は [`docs/maintainers/file-edits-rationale.md`](../../docs/maintainers/file-edits-rationale.md) にあり、常駐に残すのは指示と判断基準（「本文を丸ごと運ぶか」であってツール名ではない）だけである（joshuafolkken/kit#1150）。**Edit 自体を全文へ広げる形も同じ規則の一部である** — 数行の指摘に対する全文書き直しは、ツールを替えただけで同じコストを払っている。常駐にはその禁止の一句だけを置き、全文を書いてよい 3 条件は同じ指し先にある（joshuafolkken/kit#1260）
 
 **第 1 問で「名指しできる」となり、引き金つき配送へ移したもの**（joshuafolkken/kit#1524）。いずれも本文は消えておらず、規則が効く瞬間にフックが突きつける。下は常駐に 1 行を残した、またはその判断に理由が要った行だけであり、配送されている規則の全体ではない。**列挙表と、引き金が発火しないターンの意味の単一ソースは [`rule-delivery.md`](./rule-delivery.md) であり、ここには行数を写さない** — 2 か所に置いた数は必ずずれる（joshuafolkken/kit#1525）。