@quolu/lattice 0.74.0 → 0.76.0

package/bin/lattice.mjs

@@ -185,8 +185,9 @@ await scheduleRuntimeErrorReport();
  * 送信を有効にしていない端末では、設定fileの有無を1回見るだけで終わる。hookは打鍵ごとに走るので見ない。
  */
 async function scheduleRuntimeErrorReport() {
+  // `reporting verify`の直後は送らない。受け口は1分に1回まで受けるので、続けて送ると断られる。
   if (help !== null || args[0] === '--version' || args[0] === 'hooks'
-    || (args[0] === 'runtime-errors' && args[1] === 'report')) return;
+    || (args[0] === 'runtime-errors' && (args[1] === 'report' || (args[1] === 'reporting' && args[2] === 'verify')))) return;
   try {
     const { runtimeErrorReportingEnabled } = await import('../src/runtime-errors.mjs');
     if (!runtimeErrorReportingEnabled()) return;
@@ -222,7 +223,7 @@ function workingDirectory() {
 async function runRuntimeErrorsCli(rest) {
   const runtimeErrors = await import('../src/runtime-errors.mjs');
   const usage = () => {
-    process.stderr.write(`${JSON.stringify({ schema: 'lattice.cli_error.v2', code: 'USAGE', message: 'usage: lattice runtime-errors <snapshot [--after-cursor N] [--limit N]|ack <cursor>|diagnostics|resolve <fingerprint>|reopen <fingerprint>|compact|report|reporting <status|enable|disable>> --json' })}\n`);
+    process.stderr.write(`${JSON.stringify({ schema: 'lattice.cli_error.v2', code: 'USAGE', message: 'usage: lattice runtime-errors <snapshot [--after-cursor N] [--limit N]|ack <cursor>|diagnostics|resolve <fingerprint>|reopen <fingerprint>|compact|report|reporting <status|enable|disable|verify>> --json' })}\n`);
     return 2;
   };
   const options = { version: packageJson.version };
@@ -251,6 +252,12 @@ async function runRuntimeErrorsCli(rest) {
       result = runtimeErrors.setRuntimeErrorStatus(words[1], words[0] === 'resolve' ? 'resolved' : 'open', options);
     } else if (words[0] === 'compact' && words.length === 1) {
       result = runtimeErrors.compactRuntimeErrors(options);
+    } else if (words[0] === 'reporting' && words.length === 2 && words[1] === 'verify') {
+      // 空の報告を1通送って経路を確かめる。受領まで確かめられた時だけexit 0。
+      const reporting = await import('../src/runtime-error-reporting.mjs');
+      result = await reporting.verifyRuntimeErrorReporting(options);
+      process.stdout.write(`${JSON.stringify(result)}\n`);
+      return result.outcome === 'verified' ? 0 : 1;
     } else if (words[0] === 'reporting' && words.length === 2 && ['status', 'enable', 'disable'].includes(words[1])) {
       const reporting = await import('../src/runtime-error-reporting.mjs');
       result = words[1] === 'status' ? reporting.runtimeErrorReportingStatus(options)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.74.0",
+  "version": "0.76.0",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",

package/src/cli-help.mjs

@@ -198,6 +198,7 @@ Commands:
   compact
   report                        未受領の記録をBugHubの受け口へ送る（送信を有効にした端末だけ）
   reporting <status|enable|disable>
+  reporting verify              空の報告を1通送り、合鍵と受け口までの経路を確かめる（記録には触れない）
 `,
   bridge: `Usage: lattice bridge <command> [options] --json
 
@@ -315,7 +316,7 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'runtime-errors reopen': 'runtime-errors reopen <fingerprint> --json',
   'runtime-errors compact': 'runtime-errors compact --json',
   'runtime-errors report': 'runtime-errors report --json',
-  'runtime-errors reporting': 'runtime-errors reporting <status|enable|disable> --json',
+  'runtime-errors reporting': 'runtime-errors reporting <status|enable|disable|verify> --json',
   'bridge setup': 'bridge setup --listen <IP> [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--hub <URL>|none] [--allow-host <host>...] --json',
   'bridge reconfigure': 'bridge reconfigure [--listen <IP>] [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--hub <URL>|none] [--allow-host <host>...] --json',
   'bridge status': 'bridge status --json',

package/src/runtime-error-reporting.mjs

@@ -1,10 +1,10 @@
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import {
-  existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync,
+  existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync,
 } from 'node:fs';
 import http from 'node:http';
 import https from 'node:https';
-import { homedir } from 'node:os';
+import { homedir, platform as hostPlatform } from 'node:os';
 import { dirname, join } from 'node:path';
 
 import {
@@ -12,12 +12,14 @@ import {
   acknowledgeRuntimeErrors,
   ensureSafeDir,
   ensureSafeFile,
+  replaceStoreFile,
   runtimeErrorCollectionSupported,
   runtimeErrorReportingConfigPath,
   runtimeErrorReportingEnabled,
   runtimeErrorsDiagnostics,
   runtimeErrorsSnapshot,
   runtimeErrorsStatePath,
+  windowsLocalAppData,
 } from './runtime-errors.mjs';
 
 /**
@@ -29,6 +31,8 @@ import {
  * - 受領済みにするのは、200・`accepted: true`・`report_id`一致・応答の署名一致がそろった時だけ。
  *   そろわなければ「届いたか不明」として記録を未受領のまま残し、後から今の累計を送り直す。
  * - 送るのは`runtime-errors snapshot`が出す項目だけ。message本文・path・引数・stackは記録に無い。
+ * - `reporting verify`は、記録を載せない空の報告を1通送って、合鍵・署名・受け口までの経路を確かめる。
+ *   受け口は受領を記録するだけで、issueも通知も動かない。storeの記録と受領の印には触れない。
  */
 
 const REPORT_SCHEMA_VERSION = '1.0';
@@ -51,13 +55,34 @@ const OUTCOMES = Object.freeze(['delivered', 'nothing_pending', 'disabled', 'uns
 const plain = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const exact = (value, keys) => Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 
-export function productCredentialPath(env = process.env) {
-  return join(env.HOME || homedir(), '.config', 'bughub', 'product-credentials', `${PRODUCT_ID}.json`);
+/** 合鍵の置き場（BugHubの契約）。Windowsは`%LOCALAPPDATA%\bughub\product-credentials\`。 */
+export function productCredentialPath(env = process.env, platform = hostPlatform()) {
+  const base = platform === 'win32' ? join(windowsLocalAppData(env), 'bughub') : join(env.HOME || homedir(), '.config', 'bughub');
+  return join(base, 'product-credentials', `${PRODUCT_ID}.json`);
 }
 
 /**
- * 合鍵のfileを読む。BugHubの持ち主が置く形（本人所有・0600・symlinkでない）以外は使わない。
- * 秘密は戻り値の中だけに留め、結果や記録へ写さない。
+ * Windowsの合鍵が本人・SYSTEM・Administratorsだけのものか。DACLの読み取りは出力fileを置く場所が要るので、
+ * 絞ったstoreのフォルダを使う（無ければ作る）。合鍵のフォルダへは何も書かない。
+ */
+function windowsCredentialUnsafeReason(path, options) {
+  const storeDir = dirname(options.storePath ?? runtimeErrorsStatePath(options.env ?? process.env));
+  try {
+    ensureSafeDir(storeDir);
+  } catch {
+    return 'acl_unverifiable';
+  }
+  try {
+    ensureSafeFile(path, storeDir);
+    return null;
+  } catch {
+    return 'acl_not_owner_only';
+  }
+}
+
+/**
+ * 合鍵のfileを読む。BugHubの持ち主が置く形（symlinkでなく、POSIXは本人所有・0600、Windowsは
+ * 本人・SYSTEM・Administratorsだけに権限）以外は使わない。秘密は戻り値の中だけに留め、結果や記録へ写さない。
  */
 export function readProductCredential(options = {}) {
   const path = options.credentialPath ?? productCredentialPath(options.env ?? process.env);
@@ -68,8 +93,13 @@ export function readProductCredential(options = {}) {
     return error?.code === 'ENOENT' ? { status: 'missing' } : { status: 'unsafe', reason: 'unreadable' };
   }
   if (!stats.isFile() || stats.isSymbolicLink()) return { status: 'unsafe', reason: 'not_regular_file' };
-  if ((stats.mode & 0o777) !== 0o600) return { status: 'unsafe', reason: 'mode_not_0600' };
-  if (typeof process.getuid === 'function' && stats.uid !== process.getuid()) return { status: 'unsafe', reason: 'owner_mismatch' };
+  if (hostPlatform() === 'win32') {
+    const reason = windowsCredentialUnsafeReason(path, options);
+    if (reason !== null) return { status: 'unsafe', reason };
+  } else {
+    if ((stats.mode & 0o777) !== 0o600) return { status: 'unsafe', reason: 'mode_not_0600' };
+    if (typeof process.getuid === 'function' && stats.uid !== process.getuid()) return { status: 'unsafe', reason: 'owner_mismatch' };
+  }
   let value;
   try {
     value = JSON.parse(readFileSync(path, 'utf8'));
@@ -151,7 +181,7 @@ function writeDelivery(options, state) {
   const temporary = join(dirname(path), `.runtime-errors-delivery-${process.pid}-${randomBytes(6).toString('hex')}`);
   try {
     writeFileSync(temporary, `${JSON.stringify(state)}\n`, { mode: 0o600, flag: 'wx' });
-    renameSync(temporary, path);
+    replaceStoreFile(temporary, path);
   } finally {
     rmSync(temporary, { force: true });
   }
@@ -206,7 +236,7 @@ export function setRuntimeErrorReporting(enabled, options = {}) {
   const temporary = join(dirname(path), `.runtime-error-reporting-${process.pid}-${randomBytes(6).toString('hex')}`);
   try {
     writeFileSync(temporary, `${JSON.stringify({ schema: REPORTING_CONFIG_SCHEMA, enabled })}\n`, { mode: 0o600, flag: 'wx' });
-    renameSync(temporary, path);
+    replaceStoreFile(temporary, path);
   } finally {
     rmSync(temporary, { force: true });
   }
@@ -247,6 +277,41 @@ function parseJson(text) {
   }
 }
 
+/**
+ * 報告を1通、署名して送り、受領を確かめる。`accepted`を返すのは、200・`accepted: true`・`report_id`一致・
+ * 応答の署名一致がそろった時だけ。戻り値に秘密・key_id・宛先は入れない。
+ */
+async function sendReport({ url, keyId, secret }, snapshot, options) {
+  const now = nowMs(options);
+  const ts = Math.floor(now / 1000);
+  // `observed_at`は、載せる記録のどの時刻よりも前にしない（BugHubは観測より後の記録を断る）。秒へ切り捨てると、
+  // 記録と同じ1秒の中で送った時に記録より前へずれる。`ts`とは同じ時刻から作り、差はBugHubの許す幅（10分）に収まる。
+  const observed = Math.max(now, ...snapshot.runtime_errors.map((record) => Date.parse(record.last_seen)),
+    ...snapshot.resolutions.map((resolution) => Date.parse(resolution.resolved_at)));
+  const report = buildRuntimeErrorReport({ snapshot, version: options.version ?? 'unknown',
+    reportId: options.reportId ?? randomUUID(), observedAt: new Date(observed).toISOString() });
+  const bodyBytes = Buffer.from(JSON.stringify(report), 'utf8');
+  if (bodyBytes.length > REPORT_MAX_BYTES) return { outcome: 'too_large', reason: 'report_too_large', http_status: null };
+
+  const response = await post(url, {
+    'Content-Type': 'application/json',
+    'Content-Length': String(bodyBytes.length),
+    Authorization: `BugHub-HMAC-SHA256 key_id=${keyId}, ts=${ts}, sig=${signReport(secret, String(ts), bodyBytes)}`,
+  }, bodyBytes, options.timeoutMs ?? REQUEST_TIMEOUT_MS);
+
+  if (response.status === null) return { outcome: 'unconfirmed', reason: response.reason, http_status: null };
+  const body = parseJson(response.body);
+  if (response.status === 200) {
+    if (body === null || body.accepted !== true || body.report_id !== report.report_id
+      || !receiptSignatureMatches(secret, report.report_id, body.received_at, body.sig)) {
+      return { outcome: 'unconfirmed', reason: 'receipt_not_verified', http_status: 200 };
+    }
+    return { outcome: 'accepted', reason: null, http_status: 200 };
+  }
+  const code = typeof body?.error === 'string' && REJECTION_CODE.test(body.error) ? body.error : 'unrecognized_response';
+  return { outcome: response.status >= 500 ? 'unconfirmed' : 'rejected', reason: code, http_status: response.status };
+}
+
 /**
  * 未受領の記録を1回送る。`options.auto`の時だけ送る時機の制限を見る（手で打った`report`は見ない
  * ——多すぎればBugHubが429で断る）。戻り値に秘密・key_id・宛先は入れない。
@@ -277,13 +342,6 @@ export async function reportRuntimeErrors(options = {}) {
     if (reason !== null) return result('throttled', { reason });
   }
 
-  // `ts`と`observed_at`は同じ時刻から作る（BugHubは10分より離れた組を断る）。
-  const ts = Math.floor(nowMs(options) / 1000);
-  const report = buildRuntimeErrorReport({ snapshot: pending, version: options.version ?? 'unknown',
-    reportId: options.reportId ?? randomUUID(), observedAt: new Date(ts * 1000).toISOString() });
-  const bodyBytes = Buffer.from(JSON.stringify(report), 'utf8');
-  if (bodyBytes.length > REPORT_MAX_BYTES) return result('rejected', { reason: 'report_too_large', sent });
-
   const finish = (outcome, extra = {}) => {
     try {
       writeDelivery(options, { schema: DELIVERY_SCHEMA, last_attempt_at: new Date(nowMs(options)).toISOString(),
@@ -292,44 +350,47 @@ export async function reportRuntimeErrors(options = {}) {
     return result(outcome, { sent, acknowledged_through: pending.cursor.acknowledged_through, ...extra });
   };
 
-  const { credential: { url, keyId, secret } } = credential;
-  const response = await post(url, {
-    'Content-Type': 'application/json',
-    'Content-Length': String(bodyBytes.length),
-    Authorization: `BugHub-HMAC-SHA256 key_id=${keyId}, ts=${ts}, sig=${signReport(secret, String(ts), bodyBytes)}`,
-  }, bodyBytes, options.timeoutMs ?? REQUEST_TIMEOUT_MS);
-
-  if (response.status === null) return finish('unconfirmed', { reason: response.reason });
-  const body = parseJson(response.body);
-  if (response.status === 200) {
-    if (body === null || body.accepted !== true || body.report_id !== report.report_id
-      || !receiptSignatureMatches(secret, report.report_id, body.received_at, body.sig)) {
-      return finish('unconfirmed', { reason: 'receipt_not_verified', http_status: 200 });
-    }
-    try {
-      const acknowledged = acknowledgeRuntimeErrors(pending.cursor.next, options);
-      return finish('delivered', { http_status: 200, acknowledged_through: acknowledged.cursor.acknowledged_through });
-    } catch {
-      // 届いているが受領済みを残せなかった。次の送信が同じ累計を送り直す（BugHubは二重に数えない）。
-      return finish('unconfirmed', { reason: 'ack_not_recorded', http_status: 200 });
-    }
+  const answer = await sendReport(credential.credential, pending, options);
+  if (answer.outcome === 'too_large') return result('rejected', { reason: 'report_too_large', sent });
+  if (answer.outcome !== 'accepted') return finish(answer.outcome, { reason: answer.reason, http_status: answer.http_status });
+  try {
+    const acknowledged = acknowledgeRuntimeErrors(pending.cursor.next, options);
+    return finish('delivered', { http_status: 200, acknowledged_through: acknowledged.cursor.acknowledged_through });
+  } catch {
+    // 届いているが受領済みを残せなかった。次の送信が同じ累計を送り直す（BugHubは二重に数えない）。
+    return finish('unconfirmed', { reason: 'ack_not_recorded', http_status: 200 });
   }
-  const code = typeof body?.error === 'string' && REJECTION_CODE.test(body.error) ? body.error : 'unrecognized_response';
-  if (response.status >= 500) return finish('unconfirmed', { reason: code, http_status: response.status });
-  return finish('rejected', { reason: code, http_status: response.status });
+}
+
+/**
+ * 記録を載せない空の報告を1通送り、合鍵・署名・受け口までの経路を確かめる（`reporting verify`）。
+ * 送る条件は`report`と同じで、送信を有効にしていない端末と合鍵の無い端末はnetworkへ触れない。
+ * storeの記録・受領の印・送る時機の記録には触れない。受け口は端末×製品ごとに1分に1回まで受けるので、
+ * 直前に送っていれば429で断られる。
+ */
+export async function verifyRuntimeErrorReporting(options = {}) {
+  if (!runtimeErrorCollectionSupported(options)) return result('unsupported');
+  if (!runtimeErrorReportingEnabled(options)) return result('disabled');
+  const credential = readProductCredential(options);
+  if (credential.status === 'missing') return result('credential_missing');
+  if (credential.status !== 'ok') return result('credential_unsafe', { reason: credential.reason });
+  const answer = await sendReport(credential.credential, { runtime_errors: [], resolutions: [] }, options);
+  if (answer.outcome === 'accepted') return result('verified', { http_status: 200 });
+  return result(answer.outcome, { reason: answer.reason, http_status: answer.http_status });
 }
 
 /**
  * 自動送信の入口が、子processを起こす前に見る軽い判定。設定が無い端末（外の利用者）では、
- * 設定fileの有無を1回見るだけで終わる。
+ * 設定fileの有無を1回見るだけで終わる。合鍵は、送るものがある時だけ確かめる——Windowsでは
+ * 合鍵の確認が外のprogramを起こすので、毎回のCLI実行には載せない。
  */
 export function runtimeErrorAutoReportDue(options = {}) {
   if (!runtimeErrorReportingEnabled(options)) return false;
-  if (readProductCredential(options).status !== 'ok') return false;
   try {
     const diagnostics = runtimeErrorsDiagnostics(options);
     if (diagnostics.status !== 'ready' || diagnostics.pending_count === 0) return false;
-    return throttleReason(options, readDelivery(options), diagnostics.high_watermark) === null;
+    if (throttleReason(options, readDelivery(options), diagnostics.high_watermark) !== null) return false;
+    return readProductCredential(options).status === 'ok';
   } catch {
     return false;
   }

package/src/runtime-errors.mjs

@@ -1,10 +1,14 @@
 import { createHash, randomBytes } from 'node:crypto';
 import {
-  existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync,
+  existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync,
 } from 'node:fs';
 import { homedir, platform as hostPlatform, arch as hostArch } from 'node:os';
 import { dirname, join } from 'node:path';
 
+import {
+  daclIsOwnerOnly, daclIsProtected, isAclScratchName, readWindowsDacl, restrictWindowsDirToOwner, windowsSelfSid,
+} from './windows-owner-only.mjs';
+
 /**
  * opt-in runtime error store（親plan L6要件。Caveat `caveat.runtime_errors.v1` と同型の工場契約）。
  *
@@ -15,8 +19,9 @@ import { dirname, join } from 'node:path';
  * - privacy by design: 保存するのは固定catalogの `error_code` / `message_template` のみ。
  *   生message・path・引数を保存しない。
  * - retention: fingerprint集約（同一原因はcount/last_seen更新）＋ack済みresolvedの30日compact。
- * - POSIX専用: Lattice runtimeはWindows nativeでunsupported（親plan L6）。owner-onlyを証明できない
- *   環境では `store_unsafe` でfail closedする。
+ * - owner-only: storeは本人だけが触れる形でしか使わない。POSIXはmode（0700・0600）と所有者、Windowsは
+ *   DACL（本人・SYSTEM・Administratorsだけ、ADR 0194）で確かめ、確かめられなければ `store_unsafe` で
+ *   fail closedする。
  */
 
 const RUNTIME_ERRORS_SCHEMA = 'lattice.runtime_errors.v1';
@@ -54,7 +59,9 @@ const plain = (value) => typeof value === 'object' && value !== null && !Array.i
 const exact = (value, keys) => Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 const validTime = (value) => typeof value === 'string' && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
 const validVersion = (value) => typeof value === 'string' && /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value);
-const validOs = (value) => typeof value === 'string' && ['darwin', 'linux'].includes(value);
+// 収集に対応するOS。storeを本人だけが触れる形で置けると確かめられるものだけを載せる。
+const SUPPORTED_OS = Object.freeze(['darwin', 'linux', 'win32']);
+const validOs = (value) => typeof value === 'string' && SUPPORTED_OS.includes(value);
 const validArch = (value) => typeof value === 'string' && ['x64', 'arm64', 'arm'].includes(value);
 
 export function defaultFactoryReporterConfigPath(env = process.env) {
@@ -62,9 +69,19 @@ export function defaultFactoryReporterConfigPath(env = process.env) {
   return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'dotagents', 'factory-reporter.json');
 }
 
-export function runtimeErrorsStatePath(env = process.env) {
-  const home = env.HOME || homedir();
-  return join(env.XDG_STATE_HOME || join(home, '.local', 'state'), 'lattice', 'runtime-errors.json');
+/** Windowsで利用者ごとのdataを置く場所（`%LOCALAPPDATA%`）。 */
+export function windowsLocalAppData(env = process.env) {
+  return env.LOCALAPPDATA || join(env.USERPROFILE || homedir(), 'AppData', 'Local');
+}
+
+/**
+ * storeの置き場。Windowsは`%LOCALAPPDATA%\Lattice\runtime-errors\`という専用のフォルダへ置く
+ * ——`%LOCALAPPDATA%\Lattice`には他の機能のfileがあり、フォルダごと本人だけに絞れない。
+ */
+export function runtimeErrorsStatePath(env = process.env, platform = hostPlatform()) {
+  if (env.XDG_STATE_HOME) return join(env.XDG_STATE_HOME, 'lattice', 'runtime-errors.json');
+  if (platform === 'win32') return join(windowsLocalAppData(env), 'Lattice', 'runtime-errors', 'runtime-errors.json');
+  return join(env.HOME || homedir(), '.local', 'state', 'lattice', 'runtime-errors.json');
 }
 
 function canonicalReporting(value) {
@@ -77,19 +94,19 @@ function canonicalReporting(value) {
   return !value.enabled || (value.endpoint !== undefined && value.credential_file !== undefined);
 }
 
-// このOSで収集に対応するか。Windowsはstoreの所有者と権限をPOSIXの形で確かめられない（`ensureSafeDir`）ので
-// 対応しない。設定が有効でも記録は作らず、工場へは`disabled`でなく`unsupported`と答える——設定は有効なのに
-// 製品が黙って無効と答えると、受け側は故障と区別できない。
-const collectionSupported = (options = {}) => (options.platform ?? hostPlatform()) !== 'win32';
+// このOSで収集に対応するか。対応しないOSでは、設定が有効でも記録は作らず、`disabled`でなく`unsupported`と
+// 答える——設定は有効なのに製品が黙って無効と答えると、受け側は故障と区別できない。
+const collectionSupported = (options = {}) => SUPPORTED_OS.includes(options.platform ?? hostPlatform());
 const inactiveCollection = (options = {}) => (collectionSupported(options) ? 'disabled' : 'unsupported');
 
 export function runtimeErrorCollectionSupported(options = {}) {
   return collectionSupported(options);
 }
 
-export function runtimeErrorReportingConfigPath(env = process.env) {
-  const home = env.HOME || homedir();
-  return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'lattice', 'runtime-error-reporting.json');
+export function runtimeErrorReportingConfigPath(env = process.env, platform = hostPlatform()) {
+  if (env.XDG_CONFIG_HOME) return join(env.XDG_CONFIG_HOME, 'lattice', 'runtime-error-reporting.json');
+  if (platform === 'win32') return join(windowsLocalAppData(env), 'Lattice', 'runtime-error-reporting.json');
+  return join(env.HOME || homedir(), '.config', 'lattice', 'runtime-error-reporting.json');
 }
 
 /**
@@ -175,18 +192,63 @@ function assertPosix(info, mode) {
   if ((info.mode & 0o777) !== mode || (typeof process.getuid === 'function' && info.uid !== process.getuid())) throw Error('store_unsafe');
 }
 
+const windows = () => hostPlatform() === 'win32';
+
+/**
+ * Windowsのフォルダが本人・SYSTEM・Administratorsだけのもので、親からの継承を切ってあるか確かめる。
+ * 作ったばかりのフォルダは親の権限を継いでいるので、絞る。ただし、他のaccountが触れる形なのに中身がある
+ * フォルダは、その中身を信用できないので、絞らずに止める。
+ */
+function ensureWindowsDirOwnerOnly(dir) {
+  const sid = windowsSelfSid();
+  const settled = (sddl) => daclIsOwnerOnly(sddl, sid) && daclIsProtected(sddl);
+  const current = readWindowsDacl(dir, dir);
+  if (settled(current)) return;
+  if (!daclIsOwnerOnly(current, sid) && readdirSync(dir).some((name) => !isAclScratchName(name))) throw Error('store_unsafe');
+  restrictWindowsDirToOwner(dir, sid);
+  if (!settled(readWindowsDacl(dir, dir))) throw Error('store_unsafe');
+}
+
 export function ensureSafeDir(dir) {
-  if (hostPlatform() === 'win32') throw Error('store_unsafe');
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   const stats = lstatSync(dir);
+  // Windowsのjunctionも`isSymbolicLink`で落ちる。
   if (!stats.isDirectory() || stats.isSymbolicLink()) throw Error('store_unsafe');
-  assertPosix(stats, 0o700);
+  if (windows()) ensureWindowsDirOwnerOnly(dir);
+  else assertPosix(stats, 0o700);
 }
 
-export function ensureSafeFile(path) {
+/**
+ * `scratchDir`はWindowsだけが使う: DACLの読み取りが出力fileを置くフォルダ。既定はそのfileのフォルダ。
+ * storeの外のfile（合鍵）を確かめる時は、絞ってあるstoreのフォルダを渡す。
+ */
+export function ensureSafeFile(path, scratchDir = dirname(path)) {
   const stats = lstatSync(path);
   if (!stats.isFile() || stats.isSymbolicLink()) throw Error('store_unsafe');
-  assertPosix(statSync(path), 0o600);
+  if (!windows()) {
+    assertPosix(statSync(path), 0o600);
+    return;
+  }
+  const sid = windowsSelfSid();
+  // 出力fileを置くフォルダを他のaccountが書けるなら、読んだDACLを信用できない。先にそれを確かめる。
+  if (!daclIsOwnerOnly(readWindowsDacl(scratchDir, scratchDir), sid)
+    || !daclIsOwnerOnly(readWindowsDacl(path, scratchDir), sid)) throw Error('store_unsafe');
+}
+
+/**
+ * 一時fileを本番の名前へ置き換える。Windowsは、読み手が開いている宛先へのrenameを一時的に断るので、
+ * 少し待って繰り返す（`fs-publish.mjs`と同じ事情）。
+ */
+export function replaceStoreFile(source, destination) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      renameSync(source, destination);
+      return;
+    } catch (error) {
+      if (!windows() || !['EPERM', 'EACCES', 'EBUSY'].includes(error?.code) || attempt >= 7) throw error;
+      sleepSync(Math.min(64, 2 ** attempt));
+    }
+  }
 }
 
 const RECORD_KEYS = Object.freeze(['product', 'product_version', 'component', 'error_code', 'message_template', 'severity', 'fingerprint', 'count', 'first_seen', 'last_seen', 'state_schema_version', 'os', 'arch', 'status', 'resolved_at', 'reason_code', 'sequence']);
@@ -235,8 +297,9 @@ function writeStore(path, store) {
   const temporary = join(dirname(path), `.runtime-errors-${process.pid}-${randomBytes(6).toString('hex')}`);
   try {
     writeFileSync(temporary, `${JSON.stringify(store)}\n`, { mode: 0o600, flag: 'wx' });
-    assertPosix(statSync(temporary), 0o600);
-    renameSync(temporary, path);
+    // Windowsの一時fileはフォルダの権限を引き継ぐ。置き換えた後の`ensureSafeFile`が確かめる。
+    if (!windows()) assertPosix(statSync(temporary), 0o600);
+    replaceStoreFile(temporary, path);
     ensureSafeFile(path);
   } finally {
     rmSync(temporary, { force: true });
@@ -256,9 +319,15 @@ function lock(path, fn) {
       writeFileSync(lockPath, `${process.pid}\n`, { mode: 0o600, flag: 'wx' });
       break;
     } catch (error) {
-      if (!plain(error) || error.code !== 'EEXIST') throw error;
+      // Windowsは、消している最中のlockと同じ名前の作成を`EEXIST`でなく`EPERM`で断る。
+      if (!plain(error) || !(error.code === 'EEXIST' || (windows() && ['EPERM', 'EACCES'].includes(error.code)))) throw error;
       let age = 0;
-      try { age = Date.now() - lstatSync(lockPath).mtimeMs; } catch { continue; }
+      try {
+        age = Date.now() - lstatSync(lockPath).mtimeMs;
+      } catch {
+        if (Date.now() >= deadline) throw Error('store_locked');
+        continue;
+      }
       // crash残置lockの恒久ロックを避ける唯一の明示救済。閾値未満は正当な並行writerとして待つ。
       if (age > LOCK_STALE_MS) { try { unlinkSync(lockPath); } catch {} continue; }
       if (Date.now() >= deadline) throw Error('store_locked');

package/src/windows-owner-only.mjs

@@ -0,0 +1,95 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Windowsで「本人・SYSTEM・Administratorsだけが触れる」ことを確かめる（ADR 0194）。
+ *
+ * POSIXのmode・uidに当たるものがWindowsには無いので、DACL（誰に何を許すかの一覧）を読む。
+ * - 読み方は`icacls <path> /save <file>`。SDDLという、表示言語に依らない形で返る。
+ *   `icacls <path>`の画面表示は名前が表示言語で変わるので使わない。
+ * - 自分のSIDは`whoami /user`で得る。どちらも`%SystemRoot%\System32`の実物を絶対pathで呼ぶ
+ *   ——PATHに置かれた同名のprogramへ答えを作らせない。
+ * - 所有者は読まない（`icacls`は返さない）。空のフォルダを絞る時に所有者を本人へ替える。
+ */
+
+const SELF_SID = /^S-1-[0-9]+(?:-[0-9]+)+$/;
+const SYSTEM_SID = 'S-1-5-18';
+const ADMINISTRATORS_SID = 'S-1-5-32-544';
+const COMMAND_TIMEOUT_MS = 10_000;
+// `icacls /save`の出力fileの名前。フォルダが空かを見る時、同時に走る別processのこのfileは数えない。
+const SCRATCH_NAME = /^\.acl-\d+-[0-9a-f]{12}$/;
+
+let cachedSelfSid = null;
+
+function systemTool(name, env = process.env) {
+  return join(env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows', 'System32', name);
+}
+
+function run(tool, args) {
+  const result = spawnSync(systemTool(tool), args, { encoding: 'utf8', windowsHide: true, timeout: COMMAND_TIMEOUT_MS });
+  if (result.error || result.status !== 0) throw Error('store_unsafe');
+  return result.stdout;
+}
+
+/** このprocessを動かしている利用者のSID。process中は変わらないので1回だけ聞く。 */
+export function windowsSelfSid() {
+  if (cachedSelfSid === null) {
+    const sid = run('whoami.exe', ['/user', '/fo', 'csv', '/nh']).trim().split(',').at(-1).replaceAll('"', '');
+    if (!SELF_SID.test(sid)) throw Error('store_unsafe');
+    cachedSelfSid = sid;
+  }
+  return cachedSelfSid;
+}
+
+/**
+ * SDDLのDACLが、本人・SYSTEM・Administratorsへの許可だけで出来ているか。
+ * 読めない形（DACL無し・拒否・条件つき・object用のACE）はすべて「確かめられない」として通さない。
+ */
+export function daclIsOwnerOnly(sddl, selfSid) {
+  if (typeof sddl !== 'string' || !SELF_SID.test(selfSid)) return false;
+  const match = /^D:(?:P|AR|AI)*((?:\([^()]*\))+)$/.exec(sddl);
+  if (match === null) return false;
+  const trusted = new Set([selfSid, 'SY', SYSTEM_SID, 'BA', ADMINISTRATORS_SID]);
+  return match[1].slice(1, -1).split(')(').every((ace) => {
+    const fields = ace.split(';');
+    return fields.length === 6 && fields[0] === 'A' && fields[3] === '' && fields[4] === '' && trusted.has(fields[5]);
+  });
+}
+
+/** 親からの継承を切ってあるか（`P`）。切ってあれば、親の権限が後から変わっても降りてこない。 */
+export function daclIsProtected(sddl) {
+  return typeof sddl === 'string' && /^D:(?:AR|AI)*P/.test(sddl);
+}
+
+export const isAclScratchName = (name) => SCRATCH_NAME.test(name);
+
+/**
+ * `path`のDACLをSDDLで読む。`icacls`はfileへしか書き出せないので、出力は`scratchDir`へ置いてすぐ消す。
+ * `scratchDir`には、他のaccountが書けないフォルダ（絞ったstoreのフォルダ）を渡す——他のaccountが書ける
+ * 場所へ置くと、読む前に中身を書き換えられる。
+ */
+export function readWindowsDacl(path, scratchDir) {
+  const scratch = join(scratchDir, `.acl-${process.pid}-${randomBytes(6).toString('hex')}`);
+  try {
+    run('icacls.exe', [path, '/save', scratch]);
+    const lines = readFileSync(scratch, 'utf16le').replaceAll('\ufeff', '').split(/\r?\n/).filter((line) => line !== '');
+    // 1行目が名前、2行目がSDDL。それ以外の形は読めなかったものとして扱う。
+    if (lines.length !== 2) throw Error('store_unsafe');
+    return lines[1];
+  } finally {
+    rmSync(scratch, { force: true });
+  }
+}
+
+/**
+ * フォルダを本人・SYSTEM・Administratorsだけに絞る。親からの継承を切り、所有者を本人にする。
+ * 中に作るfileはこの権限を引き継ぎ、renameで置き換えた後も保たれる。
+ * 誰かがそのフォルダへ直接足した権限は消さない——呼び出し側が絞った後のDACLを読み直して、残っていれば止める。
+ */
+export function restrictWindowsDirToOwner(dir, selfSid) {
+  const sids = [...new Set([selfSid, SYSTEM_SID, ADMINISTRATORS_SID])];
+  run('icacls.exe', [dir, '/inheritance:r', '/grant:r', ...sids.map((sid) => `*${sid}:(OI)(CI)F`)]);
+  run('icacls.exe', [dir, '/setowner', `*${selfSid}`]);
+}