aiterm-mcp 0.12.0 → 0.12.2

package/dist/runtime-error-store.js

@@ -0,0 +1,836 @@
+import { createHash, randomBytes } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+const pkg = createRequire(import.meta.url)("../package.json");
+const STORE_SCHEMA = "aiterm-mcp.runtime-errors.v1";
+const STATE_SCHEMA = "1.0";
+const MAX_CONFIG_BYTES = 16 * 1024;
+const MAX_STORE_BYTES = 1024 * 1024;
+const WORKER_TIMEOUT_MS = 2_000;
+export const RUNTIME_ERROR_DEFINITIONS = Object.freeze({
+    "AITERM.PTY_DEPENDENCY_UNAVAILABLE": Object.freeze({
+        component: "pty-dependency", message_template: "PTY dependency is unavailable", severity: "high",
+    }),
+    "AITERM.PERSISTENCE_WRITE_FAILED": Object.freeze({
+        component: "persistence", message_template: "PTY persistence operation failed", severity: "high",
+    }),
+    "AITERM.VENDOR_LAUNCHER_FAILED": Object.freeze({
+        component: "vendor-launcher", message_template: "Optional vendor launcher failed", severity: "warn",
+    }),
+});
+const TOP_KEYS = ["schema_version", "cursor", "acknowledged_cursor", "records"];
+const RECORD_KEYS = [
+    "product", "product_version", "component", "error_code", "message_template", "severity", "fingerprint",
+    "occurrence_count", "first_seen", "last_seen", "state_schema_version", "os", "arch", "status",
+    "resolved_at", "reason_code", "sequence",
+];
+const DIAGNOSTIC_KEYS = ["status", "collection", "record_count", "unacknowledged_count"];
+const ARCHES = new Set(["x64", "arm64", "arm", "ia32"]);
+const EMPTY_STATE = () => ({ schema_version: STORE_SCHEMA, cursor: 0, acknowledged_cursor: 0, records: [] });
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+function validUtc(value) {
+    return typeof value === "string" && value.endsWith("Z") && Number.isFinite(Date.parse(value));
+}
+export function validateRuntimeObservation(value) {
+    if (!isObject(value))
+        throw new Error("runtime observation は object 必須です");
+    if (!exactKeys(value, ["code"]))
+        throw new Error("runtime observation に allowlist 外 field があります");
+    if (typeof value.code !== "string" || !(value.code in RUNTIME_ERROR_DEFINITIONS)) {
+        throw new Error("runtime observation code は allowlist 外です");
+    }
+    return { code: value.code };
+}
+export function defaultRuntimeErrorPaths(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const home = options.home ?? os.homedir();
+    if (platform === "win32") {
+        const base = options.localAppData ?? process.env.LOCALAPPDATA ?? path.win32.join(home, "AppData", "Local");
+        return {
+            configPath: path.win32.join(base, "dotagents", "factory-reporter", "config.json"),
+            storePath: path.win32.join(base, "aiterm-mcp", "runtime-errors.json"),
+        };
+    }
+    const configHome = options.xdgConfigHome ?? process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    const stateHome = options.xdgStateHome ?? process.env.XDG_STATE_HOME ?? path.join(home, ".local", "state");
+    return {
+        configPath: path.join(configHome, "dotagents", "factory-reporter.json"),
+        storePath: path.join(stateHome, "aiterm-mcp", "runtime-errors.json"),
+    };
+}
+const WINDOWS_DACL_VERIFY_SCRIPT = String.raw `
+$ErrorActionPreference='Stop'
+$target=$env:AITERMMCP_ACL_PATH; $kind=$env:AITERMMCP_ACL_KIND
+$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User
+$check=if($kind -eq 'directory'){[IO.Directory]::GetAccessControl($target)}else{[IO.File]::GetAccessControl($target)}
+$ownerSid=$check.GetOwner([Security.Principal.SecurityIdentifier]).Value
+$rules=@($check.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]))
+if($ownerSid -ne $sid.Value -or $rules.Count -ne 1 -or $rules[0].IdentityReference.Value -ne $sid.Value -or $rules[0].AccessControlType -ne 'Allow' -or $rules[0].IsInherited -or (($rules[0].FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -ne [Security.AccessControl.FileSystemRights]::FullControl)){exit 9}
+`;
+const WINDOWS_DACL_SCRIPT = String.raw `
+$ErrorActionPreference='Stop'
+$target=$env:AITERMMCP_ACL_PATH; $kind=$env:AITERMMCP_ACL_KIND
+$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User
+if($kind -eq 'directory'){$acl=New-Object Security.AccessControl.DirectorySecurity;$inherit=[Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'}else{$acl=New-Object Security.AccessControl.FileSecurity;$inherit=[Security.AccessControl.InheritanceFlags]::None}
+$acl.SetOwner($sid); $acl.SetAccessRuleProtection($true,$false)
+$rule=New-Object Security.AccessControl.FileSystemAccessRule($sid,[Security.AccessControl.FileSystemRights]::FullControl,$inherit,[Security.AccessControl.PropagationFlags]::None,[Security.AccessControl.AccessControlType]::Allow)
+$acl.AddAccessRule($rule); if($kind -eq 'directory'){[IO.Directory]::SetAccessControl($target,$acl)}else{[IO.File]::SetAccessControl($target,$acl)}
+` + WINDOWS_DACL_VERIFY_SCRIPT;
+export function windowsPrivateDaclCommand(target, kind = "directory") {
+    return {
+        command: "powershell.exe",
+        args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", WINDOWS_DACL_SCRIPT],
+        env: { ...process.env, AITERMMCP_ACL_PATH: target, AITERMMCP_ACL_KIND: kind },
+    };
+}
+export function windowsPrivateDaclVerifyCommand(target, kind = "file") {
+    return {
+        command: "powershell.exe",
+        args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", WINDOWS_DACL_VERIFY_SCRIPT],
+        env: { ...process.env, AITERMMCP_ACL_PATH: target, AITERMMCP_ACL_KIND: kind },
+    };
+}
+function expectedHostProfile(platform) {
+    if (platform === "darwin")
+        return "mac";
+    if (platform === "win32")
+        return "windows-native";
+    return process.env.WSL_DISTRO_NAME || /microsoft/i.test(os.release()) ? "wsl" : "server";
+}
+function assertPrivatePosixStat(info, expectedMode, label) {
+    if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1)
+        throw new Error(`${label} が安全な regular file ではありません`);
+    if (typeof process.getuid !== "function" || info.uid !== process.getuid())
+        throw new Error(`${label} owner が不正です`);
+    if ((info.mode & 0o777) !== expectedMode)
+        throw new Error(`${label} mode が不正です`);
+}
+function readBoundedFile(file, maxBytes, platform, requirePrivate) {
+    if (platform === "win32") {
+        const before = fs.lstatSync(file);
+        if (!before.isFile() || before.isSymbolicLink() || before.size > maxBytes)
+            throw new Error("file shape/size が不正です");
+        if (requirePrivate) {
+            const command = windowsPrivateDaclVerifyCommand(file);
+            const verified = spawnSync(command.command, command.args, { encoding: "utf8", windowsHide: true, timeout: 5000, maxBuffer: 16 * 1024, env: command.env });
+            if (verified.error || verified.status !== 0)
+                throw new Error("file DACL が不正です");
+        }
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        try {
+            const after = fs.fstatSync(fd);
+            if (before.dev !== after.dev || before.ino !== after.ino || after.size > maxBytes)
+                throw new Error("file が read 中に置換されました");
+            return fs.readFileSync(fd, "utf8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    const before = fs.lstatSync(file);
+    if (requirePrivate)
+        assertPrivatePosixStat(before, 0o600, "runtime store/config");
+    else if (!before.isFile() || before.isSymbolicLink())
+        throw new Error("file が regular ではありません");
+    if (before.size > maxBytes)
+        throw new Error("file が大きすぎます");
+    const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | noFollow);
+    try {
+        const after = fs.fstatSync(fd);
+        if (before.dev !== after.dev || before.ino !== after.ino)
+            throw new Error("file が read 中に置換されました");
+        if (requirePrivate)
+            assertPrivatePosixStat(after, 0o600, "runtime store/config");
+        return fs.readFileSync(fd, "utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function validateCanonicalConfig(config, platform) {
+    if (!isObject(config) || !exactKeys(config, ["schema_version", "host", "collection", "reporting"]))
+        return false;
+    if (config.schema_version !== "1.0" || !isObject(config.host) || !exactKeys(config.host, ["id", "profile"]))
+        return false;
+    if (typeof config.host.id !== "string" || config.host.id.length < 1 || config.host.id.length > 64
+        || !/^[a-z0-9][a-z0-9._-]*$/.test(config.host.id))
+        return false;
+    if (config.host.profile !== expectedHostProfile(platform))
+        return false;
+    if (!isObject(config.collection) || !exactKeys(config.collection, ["enabled"])
+        || typeof config.collection.enabled !== "boolean")
+        return false;
+    if (!isObject(config.reporting))
+        return false;
+    const reportingKeys = Object.keys(config.reporting);
+    if (reportingKeys.some((key) => !["enabled", "endpoint", "credential_file"].includes(key))
+        || !reportingKeys.includes("enabled") || typeof config.reporting.enabled !== "boolean")
+        return false;
+    if ("endpoint" in config.reporting) {
+        if (typeof config.reporting.endpoint !== "string" || config.reporting.endpoint.length > 2048
+            || !/^https?:\/\//.test(config.reporting.endpoint))
+            return false;
+        try {
+            if (!["http:", "https:"].includes(new URL(config.reporting.endpoint).protocol))
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    if ("credential_file" in config.reporting
+        && (typeof config.reporting.credential_file !== "string"
+            || config.reporting.credential_file.length < 1 || config.reporting.credential_file.length > 4096))
+        return false;
+    if (config.reporting.enabled && (!("endpoint" in config.reporting) || !("credential_file" in config.reporting)))
+        return false;
+    return true;
+}
+function collectionStatus(configPath, platform) {
+    let text;
+    try {
+        text = readBoundedFile(configPath, MAX_CONFIG_BYTES, platform, true);
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? "disabled" : "malformed";
+    }
+    try {
+        const config = JSON.parse(text);
+        if (!validateCanonicalConfig(config, platform))
+            return "malformed";
+        return config.collection.enabled ? "enabled" : "disabled";
+    }
+    catch {
+        return "malformed";
+    }
+}
+function platformName(platform) {
+    return platform === "win32" ? "windows" : platform === "darwin" ? "darwin" : "linux";
+}
+function fingerprintFor(code) {
+    const definition = RUNTIME_ERROR_DEFINITIONS[code];
+    return createHash("sha256").update(["aiterm-mcp", definition.component, code, definition.message_template].join("\0")).digest("hex");
+}
+function projectRecord(record) {
+    return Object.fromEntries(RECORD_KEYS.map((key) => [key, record[key]]));
+}
+function validateRecord(value, cursor) {
+    if (!isObject(value) || !exactKeys(value, RECORD_KEYS))
+        return null;
+    if (value.product !== "aiterm-mcp" || typeof value.product_version !== "string"
+        || !/^[0-9A-Za-z][0-9A-Za-z.+_-]{0,127}$/.test(value.product_version))
+        return null;
+    if (typeof value.error_code !== "string" || !(value.error_code in RUNTIME_ERROR_DEFINITIONS))
+        return null;
+    const code = value.error_code;
+    const def = RUNTIME_ERROR_DEFINITIONS[code];
+    if (value.component !== def.component || value.message_template !== def.message_template || value.severity !== def.severity
+        || value.fingerprint !== fingerprintFor(code))
+        return null;
+    if (!Number.isSafeInteger(value.occurrence_count) || Number(value.occurrence_count) < 1
+        || !validUtc(value.first_seen) || !validUtc(value.last_seen)
+        || Date.parse(value.first_seen) > Date.parse(value.last_seen))
+        return null;
+    if (value.state_schema_version !== STATE_SCHEMA || !["darwin", "linux", "windows"].includes(String(value.os))
+        || typeof value.arch !== "string" || !ARCHES.has(value.arch)
+        || !["open", "resolved"].includes(String(value.status)))
+        return null;
+    if ((value.status === "open" && (value.resolved_at !== null || value.reason_code !== null))
+        || (value.status === "resolved" && (!validUtc(value.resolved_at)
+            || Date.parse(value.resolved_at) < Date.parse(value.last_seen)
+            || value.reason_code !== "operator_resolved")))
+        return null;
+    if (!Number.isSafeInteger(value.sequence) || Number(value.sequence) < 1 || Number(value.sequence) > cursor)
+        return null;
+    return projectRecord(value);
+}
+function validateState(value, maxRecords = 256) {
+    if (!isObject(value) || !exactKeys(value, TOP_KEYS) || value.schema_version !== STORE_SCHEMA
+        || !Number.isSafeInteger(value.cursor) || Number(value.cursor) < 0
+        || !Number.isSafeInteger(value.acknowledged_cursor) || Number(value.acknowledged_cursor) < 0
+        || Number(value.acknowledged_cursor) > Number(value.cursor)
+        || !Array.isArray(value.records) || value.records.length > maxRecords)
+        return null;
+    const records = value.records.map((record) => validateRecord(record, Number(value.cursor)));
+    if (records.some((record) => record === null))
+        return null;
+    const typed = records;
+    if (new Set(typed.map((record) => record.fingerprint)).size !== typed.length
+        || new Set(typed.map((record) => record.sequence)).size !== typed.length)
+        return null;
+    return {
+        schema_version: STORE_SCHEMA,
+        cursor: Number(value.cursor),
+        acknowledged_cursor: Number(value.acknowledged_cursor),
+        records: typed.map((record) => projectRecord(record)),
+    };
+}
+function processStartIdentity(pid, platform) {
+    if (!Number.isInteger(pid) || pid < 1)
+        return null;
+    if (platform === "linux") {
+        try {
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+            const close = stat.lastIndexOf(")");
+            const fields = stat.slice(close + 2).split(" ");
+            return fields[19] ? `linux:${fields[19]}` : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (platform === "win32") {
+        const script = "$p=Get-Process -Id $env:AITERMMCP_PROCESS_ID -ErrorAction Stop; $p.StartTime.ToUniversalTime().Ticks";
+        const result = spawnSync("powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], {
+            encoding: "utf8", timeout: 1000, maxBuffer: 4096, windowsHide: true,
+            env: { ...process.env, AITERMMCP_PROCESS_ID: String(pid) },
+        });
+        const value = result.status === 0 ? (result.stdout ?? "").trim() : "";
+        return /^\d+$/.test(value) ? `win32:${value}` : null;
+    }
+    const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", timeout: 1000, maxBuffer: 4096 });
+    const value = result.status === 0 ? (result.stdout ?? "").trim() : "";
+    return value ? `${platform}:${value}` : null;
+}
+export class RuntimeErrorStore {
+    configPath;
+    storePath;
+    platform;
+    arch;
+    productVersion;
+    now;
+    stderr;
+    maxRecords;
+    windowsAclTimeoutMs;
+    constructor(options = {}) {
+        const defaults = defaultRuntimeErrorPaths(options);
+        this.configPath = options.configPath ?? defaults.configPath;
+        this.storePath = options.storePath ?? defaults.storePath;
+        this.platform = options.platform ?? process.platform;
+        if (!ARCHES.has(options.arch ?? process.arch))
+            throw new Error("arch が不正です");
+        this.arch = (options.arch ?? process.arch);
+        this.productVersion = options.productVersion ?? pkg.version;
+        this.now = options.now ?? (() => new Date());
+        this.stderr = options.stderr ?? ((line) => process.stderr.write(line));
+        this.maxRecords = options.maxRecords ?? 256;
+        this.windowsAclTimeoutMs = options.windowsAclTimeoutMs ?? 5000;
+        if (!Number.isInteger(this.maxRecords) || this.maxRecords < 1 || this.maxRecords > 256)
+            throw new Error("maxRecords は 1..256 必須です");
+    }
+    collectionStatus() { return collectionStatus(this.configPath, this.platform); }
+    assertPrivateDirectory(dir) {
+        const info = fs.lstatSync(dir);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("runtime error store directory が安全ではありません");
+        if (this.platform !== "win32") {
+            if (typeof process.getuid !== "function" || info.uid !== process.getuid() || (info.mode & 0o777) !== 0o700) {
+                throw new Error("runtime error store directory owner/mode が不正です");
+            }
+        }
+    }
+    readState() {
+        const dir = path.dirname(this.storePath);
+        try {
+            this.assertPrivateDirectory(dir);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return EMPTY_STATE();
+            throw error;
+        }
+        if (this.platform === "win32") {
+            this.applyWindowsDacl(dir, "directory");
+            if (fs.existsSync(this.storePath))
+                this.applyWindowsDacl(this.storePath, "file");
+        }
+        let text;
+        try {
+            text = readBoundedFile(this.storePath, MAX_STORE_BYTES, this.platform, this.platform !== "win32");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return EMPTY_STATE();
+            throw error;
+        }
+        const state = validateState(JSON.parse(text), this.maxRecords);
+        if (!state)
+            throw new Error("runtime error store schema が不正です");
+        return state;
+    }
+    applyWindowsDacl(target, kind) {
+        const command = windowsPrivateDaclCommand(target, kind);
+        const result = spawnSync(command.command, command.args, {
+            encoding: "utf8", windowsHide: true, timeout: this.windowsAclTimeoutMs, maxBuffer: 16 * 1024, env: command.env,
+        });
+        if (result.error || result.status !== 0)
+            throw new Error("Windows private DACL の適用/readback に失敗しました");
+    }
+    ensurePrivateDirectory() {
+        const dir = path.dirname(this.storePath);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (this.platform === "win32")
+            this.applyWindowsDacl(dir, "directory");
+        else
+            fs.chmodSync(dir, 0o700);
+        this.assertPrivateDirectory(dir);
+    }
+    atomicWrite(state) {
+        const validated = validateState(state, this.maxRecords);
+        if (!validated)
+            throw new Error("書込 state が不正です");
+        this.ensurePrivateDirectory();
+        const dir = path.dirname(this.storePath);
+        const temp = path.join(dir, `.${path.basename(this.storePath)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+        let fd = null;
+        try {
+            fd = fs.openSync(temp, "wx", 0o600);
+            fs.writeFileSync(fd, JSON.stringify(validated) + "\n", "utf8");
+            fs.fsyncSync(fd);
+            fs.closeSync(fd);
+            fd = null;
+            fs.renameSync(temp, this.storePath);
+            if (this.platform === "win32")
+                this.applyWindowsDacl(this.storePath, "file");
+            else
+                fs.chmodSync(this.storePath, 0o600);
+        }
+        finally {
+            if (fd !== null)
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { /* noop */ }
+            try {
+                fs.unlinkSync(temp);
+            }
+            catch { /* renamed or cleanup */ }
+        }
+    }
+    readLock(lock) {
+        let text;
+        if (this.platform === "win32") {
+            this.applyWindowsDacl(lock, "file");
+            text = readBoundedFile(lock, 4096, this.platform, false);
+        }
+        else {
+            const before = fs.lstatSync(lock);
+            if (!before.isFile() || before.isSymbolicLink() || before.nlink < 1 || before.nlink > 2
+                || before.uid !== process.getuid() || (before.mode & 0o777) !== 0o600 || before.size > 4096) {
+                throw new Error("runtime error store lock が不正です");
+            }
+            const fd = fs.openSync(lock, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | (fs.constants.O_NOFOLLOW ?? 0));
+            try {
+                const after = fs.fstatSync(fd);
+                if (before.dev !== after.dev || before.ino !== after.ino || after.nlink < 1 || after.nlink > 2) {
+                    throw new Error("runtime error store lock が置換されました");
+                }
+                text = fs.readFileSync(fd, "utf8");
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        const parsed = JSON.parse(text);
+        if (!isObject(parsed) || !exactKeys(parsed, ["pid", "start_id", "token"])
+            || !Number.isInteger(parsed.pid) || Number(parsed.pid) < 1
+            || typeof parsed.start_id !== "string" || parsed.start_id.length > 256
+            || typeof parsed.token !== "string" || !/^[0-9a-f]{32}$/.test(parsed.token))
+            throw new Error("runtime error store lock が不正です");
+        return { pid: Number(parsed.pid), start_id: parsed.start_id, token: parsed.token };
+    }
+    publishOwnerFile(target, owner) {
+        const queue = path.dirname(target);
+        const temporary = `${queue}.publish.${owner.token}.${randomBytes(8).toString("hex")}.tmp`;
+        let fd = fs.openSync(temporary, "wx", 0o600);
+        try {
+            fs.writeFileSync(fd, JSON.stringify(owner) + "\n", "utf8");
+            fs.fsyncSync(fd);
+            fs.closeSync(fd);
+            fd = -1;
+            if (this.platform === "win32")
+                this.applyWindowsDacl(temporary, "file");
+            fs.renameSync(temporary, target);
+        }
+        finally {
+            if (fd >= 0)
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { /* noop */ }
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { /* rename済みまたはcleanup済み */ }
+        }
+    }
+    withLock(fn) {
+        this.ensurePrivateDirectory();
+        const queue = `${this.storePath}.lock-queue`;
+        try {
+            fs.mkdirSync(queue, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        if (this.platform === "win32")
+            this.applyWindowsDacl(queue, "directory");
+        else {
+            const info = fs.lstatSync(queue);
+            if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== process.getuid()
+                || (info.mode & 0o777) !== 0o700)
+                throw new Error("runtime error lock queue のowner/modeが不正です");
+        }
+        const startId = processStartIdentity(process.pid, this.platform);
+        if (!startId)
+            throw new Error("process start identity を取得できません");
+        const owner = { pid: process.pid, start_id: startId, token: randomBytes(16).toString("hex") };
+        const ticketPattern = /^(\d{16})-([0-9a-f]{32})\.ticket$/;
+        const choosingPattern = /^choosing-([0-9a-f]{32})\.json$/;
+        const choosing = path.join(queue, `choosing-${owner.token}.json`);
+        let ticket = null;
+        try {
+            this.publishOwnerFile(choosing, owner);
+            let maximum = 0;
+            for (const name of fs.readdirSync(queue)) {
+                const match = ticketPattern.exec(name);
+                if (!match) {
+                    if (choosingPattern.test(name))
+                        continue;
+                    throw new Error("runtime error lock queue に不正なentryがあります");
+                }
+                maximum = Math.max(maximum, Number(match[1]));
+            }
+            if (!Number.isSafeInteger(maximum) || maximum >= 9_999_999_999_999_999) {
+                throw new Error("runtime error lock ticket が上限に達しました");
+            }
+            const ticketNumber = maximum + 1;
+            const ticketName = `${String(ticketNumber).padStart(16, "0")}-${owner.token}.ticket`;
+            ticket = path.join(queue, ticketName);
+            this.publishOwnerFile(ticket, owner);
+            fs.unlinkSync(choosing);
+            const deadline = Date.now() + 1_500;
+            for (;;) {
+                const names = fs.readdirSync(queue).sort();
+                let hasLiveChoosing = false;
+                for (const name of names.filter((candidate) => choosingPattern.test(candidate))) {
+                    const currentPath = path.join(queue, name);
+                    let current;
+                    try {
+                        current = this.readLock(currentPath);
+                    }
+                    catch (error) {
+                        if (error.code === "ENOENT"
+                            || (error instanceof Error && error.message.includes("置換されました")))
+                            continue;
+                        throw error;
+                    }
+                    if (name !== `choosing-${current.token}.json`)
+                        throw new Error("runtime error choosing entry が不正です");
+                    const identity = processStartIdentity(current.pid, this.platform);
+                    const live = identity === current.start_id || (!identity && processExists(current.pid));
+                    if (live)
+                        hasLiveChoosing = true;
+                    else {
+                        try {
+                            fs.unlinkSync(currentPath);
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT")
+                                throw error;
+                        }
+                    }
+                }
+                if (hasLiveChoosing) {
+                    if (Date.now() >= deadline)
+                        throw new Error("runtime error store is busy");
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+                    continue;
+                }
+                let firstLive = null;
+                const ticketNames = fs.readdirSync(queue).sort();
+                for (const name of ticketNames.filter((candidate) => ticketPattern.test(candidate))) {
+                    const currentPath = path.join(queue, name);
+                    let current;
+                    try {
+                        current = this.readLock(currentPath);
+                    }
+                    catch (error) {
+                        if (error.code === "ENOENT"
+                            || (error instanceof Error && error.message.includes("置換されました")))
+                            continue;
+                        throw error;
+                    }
+                    if (!name.endsWith(`-${current.token}.ticket`))
+                        throw new Error("runtime error lock ticket が不正です");
+                    const identity = processStartIdentity(current.pid, this.platform);
+                    const live = identity === current.start_id || (!identity && processExists(current.pid));
+                    if (!live) {
+                        try {
+                            fs.unlinkSync(currentPath);
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT")
+                                throw error;
+                        }
+                        continue;
+                    }
+                    firstLive = name;
+                    break;
+                }
+                if (firstLive === ticketName)
+                    break;
+                if (Date.now() >= deadline)
+                    throw new Error("runtime error store is busy");
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+            }
+            return fn();
+        }
+        finally {
+            try {
+                fs.unlinkSync(choosing);
+            }
+            catch { /* publish前failureまたは既にticket化 */ }
+            if (ticket) {
+                try {
+                    const current = this.readLock(ticket);
+                    if (current.token === owner.token && current.pid === owner.pid && current.start_id === owner.start_id) {
+                        fs.unlinkSync(ticket);
+                    }
+                }
+                catch { /* 自分の固有ticketだけを片付ける */ }
+            }
+        }
+    }
+    compactAcknowledgedResolved(state) {
+        if (state.records.length < this.maxRecords)
+            return;
+        state.records = state.records.filter((record) => !(record.status === "resolved" && record.sequence <= state.acknowledged_cursor));
+    }
+    record(value) {
+        const observation = validateRuntimeObservation(value);
+        if (this.collectionStatus() !== "enabled")
+            return false;
+        return this.withLock(() => {
+            const state = this.readState();
+            const definition = RUNTIME_ERROR_DEFINITIONS[observation.code];
+            const fingerprint = fingerprintFor(observation.code);
+            let record = state.records.find((item) => item.fingerprint === fingerprint);
+            if (!record) {
+                this.compactAcknowledgedResolved(state);
+                if (state.records.length >= this.maxRecords)
+                    throw new Error("runtime error store capacity reached; unacknowledged records are preserved");
+            }
+            const seen = this.now().toISOString();
+            const sequence = state.cursor + 1;
+            if (record) {
+                record.occurrence_count += 1;
+                record.last_seen = seen;
+                record.status = "open";
+                record.resolved_at = null;
+                record.reason_code = null;
+                record.sequence = sequence;
+            }
+            else {
+                record = {
+                    product: "aiterm-mcp", product_version: this.productVersion, component: definition.component,
+                    error_code: observation.code, message_template: definition.message_template, severity: definition.severity,
+                    fingerprint, occurrence_count: 1, first_seen: seen, last_seen: seen, state_schema_version: STATE_SCHEMA,
+                    os: platformName(this.platform), arch: this.arch, status: "open",
+                    resolved_at: null, reason_code: null, sequence,
+                };
+                state.records.push(record);
+            }
+            state.cursor = sequence;
+            this.atomicWrite(state);
+            return true;
+        });
+    }
+    tryRecord(value) {
+        const observation = validateRuntimeObservation(value);
+        try {
+            return this.record(observation);
+        }
+        catch {
+            this.stderr("aiterm: runtime error store unavailable\n");
+            return false;
+        }
+    }
+    snapshot() {
+        const collection = this.collectionStatus();
+        const state = collection === "enabled" ? this.readState() : EMPTY_STATE();
+        return {
+            collection, schema_version: state.schema_version, cursor: state.cursor,
+            acknowledged_cursor: state.acknowledged_cursor,
+            records: state.records.map((record) => projectRecord(record)),
+        };
+    }
+    changeStatus(fingerprint, status) {
+        if (!/^[0-9a-f]{64}$/.test(fingerprint))
+            throw new Error("fingerprint が不正です");
+        if (this.collectionStatus() !== "enabled")
+            return false;
+        return this.withLock(() => {
+            const state = this.readState();
+            const record = state.records.find((item) => item.fingerprint === fingerprint);
+            if (!record)
+                return false;
+            if (record.status === status)
+                return true;
+            state.cursor += 1;
+            record.status = status;
+            record.resolved_at = status === "resolved" ? this.now().toISOString() : null;
+            record.reason_code = status === "resolved" ? "operator_resolved" : null;
+            record.sequence = state.cursor;
+            this.atomicWrite(state);
+            return true;
+        });
+    }
+    resolve(fingerprint) { return this.changeStatus(fingerprint, "resolved"); }
+    reopen(fingerprint) { return this.changeStatus(fingerprint, "open"); }
+    acknowledge(cursor) {
+        if (!Number.isSafeInteger(cursor) || cursor < 0)
+            throw new Error("ack cursor が不正です");
+        if (this.collectionStatus() !== "enabled")
+            return this.snapshot();
+        this.withLock(() => {
+            const state = this.readState();
+            if (cursor < state.acknowledged_cursor)
+                throw new Error("ack cursor must be monotonic");
+            if (cursor > state.cursor)
+                throw new Error("ack cursor is ahead of current cursor");
+            state.acknowledged_cursor = cursor;
+            this.atomicWrite(state);
+        });
+        return this.snapshot();
+    }
+    diagnostic() {
+        const collection = this.collectionStatus();
+        if (collection === "disabled")
+            return { status: "not_applicable", collection, record_count: 0, unacknowledged_count: 0 };
+        if (collection === "malformed")
+            return { status: "unverified", collection, record_count: null, unacknowledged_count: null };
+        try {
+            const state = this.readState();
+            return { status: "ready", collection, record_count: state.records.length,
+                unacknowledged_count: state.records.filter((record) => record.sequence > state.acknowledged_cursor).length };
+        }
+        catch {
+            return { status: "unverified", collection, record_count: null, unacknowledged_count: null };
+        }
+    }
+}
+const WORKER = fileURLToPath(new URL("./runtime-error-worker.js", import.meta.url));
+function fixedStoreFailure(stderr) { stderr("aiterm: runtime error store unavailable\n"); }
+export function recordRuntimeError(code, options = {}) {
+    validateRuntimeObservation({ code });
+    const stderr = options.stderr ?? ((line) => process.stderr.write(line));
+    let reported = false;
+    const report = () => { if (!reported) {
+        reported = true;
+        fixedStoreFailure(stderr);
+    } };
+    try {
+        const child = spawn(process.execPath, [options.workerPath ?? WORKER, "record", code], {
+            stdio: "ignore", windowsHide: true, env: process.env,
+        });
+        const timer = setTimeout(() => { report(); forceKill(child); }, options.timeoutMs ?? WORKER_TIMEOUT_MS);
+        timer.unref();
+        child.once("error", report);
+        child.once("exit", (exitCode, signal) => { clearTimeout(timer); if (exitCode !== 0 || signal)
+            report(); });
+        child.unref();
+        return true;
+    }
+    catch {
+        report();
+        return false;
+    }
+}
+function validDiagnostic(value) {
+    if (!isObject(value) || !exactKeys(value, DIAGNOSTIC_KEYS))
+        return false;
+    return ["ready", "not_applicable", "unverified"].includes(String(value.status))
+        && ["enabled", "disabled", "malformed"].includes(String(value.collection))
+        && [value.record_count, value.unacknowledged_count].every((item) => item === null || (Number.isInteger(item) && Number(item) >= 0));
+}
+export async function runtimeErrorStoreDiagnostic(options = {}) {
+    const fallback = { status: "unverified", collection: "malformed", record_count: null, unacknowledged_count: null };
+    return await new Promise((resolve) => {
+        let settled = false;
+        let stdout = "";
+        const finish = (value) => { if (!settled) {
+            settled = true;
+            resolve(value);
+        } };
+        let child;
+        try {
+            child = spawn(process.execPath, [options.workerPath ?? WORKER, "diagnostic"], {
+                stdio: ["ignore", "pipe", "ignore"], windowsHide: true, env: process.env,
+            });
+        }
+        catch {
+            finish(fallback);
+            return;
+        }
+        const timer = setTimeout(() => { forceKill(child); finish(fallback); }, options.timeoutMs ?? WORKER_TIMEOUT_MS);
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => { if (stdout.length <= 4096)
+            stdout += chunk; });
+        child.once("error", () => { clearTimeout(timer); finish(fallback); });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0 || stdout.length > 4096) {
+                finish(fallback);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                finish(validDiagnostic(parsed) ? parsed : fallback);
+            }
+            catch {
+                finish(fallback);
+            }
+        });
+    });
+}
+function forceKill(child) {
+    if (!Number.isSafeInteger(child.pid) || !child.pid)
+        return;
+    if (process.platform !== "win32") {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already exited */ }
+        return;
+    }
+    const killer = spawn("taskkill.exe", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore", windowsHide: true,
+    });
+    killer.once("error", () => { try {
+        child.kill("SIGKILL");
+    }
+    catch { /* already exited */ } });
+    killer.unref();
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}