@shinaps/skills 0.43.0 → 0.44.0

package/README.md

@@ -8,7 +8,7 @@ Claude Code と Codex で使う、開発ワークフローのスキル集です
 ## 必要なもの
 
 - Claude Code または Codex CLI
-- Node.js 22 以上（Codex への導入と、設定の検証・Managed Agents の操作に使う[配布 CLI](docs/install.md#配布-cli)に必要）
+- Node.js 22.13 以上の 22 系、または 24 以上（Codex への導入と、設定の検証・Managed Agents の操作・規約の機械検査に使う[配布 CLI](docs/install.md#配布-cli)に必要。機械検査の ESLint の要件に合わせている）。配布 CLI は機械検査のために ESLint・typescript-eslint・TypeScript などを依存に持ち、導入に約 50MB を使います。
 - 機能によって追加で必要なもの（Linear・Claude Managed Agents など）は、下の「機能別の資料」の各資料に書いています。
 
 ## インストール

package/dist/bin/skills.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { packageRoot } from '../lib/layout.js';
-import { validateLinearConfig } from '../lib/linear-config.js';
-import { validateManagedConfig } from '../lib/managed-config.js';
-import { managed } from '../lib/managed.js';
-import { run } from '../lib/install.js';
-import { autoUpdate } from '../lib/auto-update.js';
-import { errorMessage } from '../lib/fs.js';
+import { packageRoot } from "../lib/layout.js";
+import { validateLinearConfig } from "../lib/linear-config.js";
+import { validateManagedConfig } from "../lib/managed-config.js";
+import { managed } from "../lib/managed.js";
+import { run } from "../lib/install.js";
+import { autoUpdate } from "../lib/auto-update.js";
+import { lint } from "../lib/lint.js";
+import { errorMessage } from "../lib/fs.js";
 const [command, ...rest] = process.argv.slice(2);
 try {
     if (command === '--version') {
@@ -29,6 +30,8 @@ try {
         await managed(rest);
     else if (command === 'auto-update')
         await autoUpdate(rest);
+    else if (command === 'lint')
+        await lint(rest);
     else
         await run(process.argv.slice(2));
 }

package/dist/lib/auto-update.js

@@ -2,10 +2,10 @@ import { mkdir, writeFile, rm } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { execFileSync, spawnSync } from 'node:child_process';
-import { withLock } from './lock.js';
-import { install, openInstallation, recover } from './install.js';
-import { errorMessage, readJson, readJsonIfExists } from './fs.js';
-import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedRoot, manifestPath, payloadDir, statePath, } from './layout.js';
+import { withLock } from "./lock.js";
+import { install, openInstallation, recover } from "./install.js";
+import { errorMessage, readJson, readJsonIfExists } from "./fs.js";
+import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedRoot, manifestPath, payloadDir, statePath, } from "./layout.js";
 const actions = ['enable', 'disable', 'status', 'check'];
 const isAction = (value) => actions.includes(value);
 const label = 'io.shinaps.skills.update';

package/dist/lib/config-validation.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Ajv } from 'ajv';
-import { packageRoot } from './layout.js';
+import { packageRoot } from "./layout.js";
 /** 明示されたファイルを同梱の契約で検証し、検証した内容を返す。設定の探索・変更や外部取得は行わない。 */
 export async function validateConfig(path, contract) {
     const input = JSON.parse(await readFile(path, 'utf8'));

package/dist/lib/install.js

@@ -2,10 +2,10 @@ import { readFile, readdir, cp, rm, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { digest, registerPlugin, replaceInstallation, restore, } from './transaction.js';
-import { withLock } from './lock.js';
-import { readTextIfExists, writeFileAtomic } from './fs.js';
-import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedAgent, managedRoot, marketplaceName, packageRoot, payloadDir, payloadPaths, pluginDir, pluginId, statePath, } from './layout.js';
+import { digest, registerPlugin, replaceInstallation, restore, } from "./transaction.js";
+import { withLock } from "./lock.js";
+import { readTextIfExists, writeFileAtomic } from "./fs.js";
+import { codexHomeMismatch, codexHomeOf, isRecordedCodexHome, managedAgent, managedRoot, marketplaceName, packageRoot, payloadDir, payloadPaths, pluginDir, pluginId, statePath, } from "./layout.js";
 const actions = ['install', 'update', 'uninstall', 'recover'];
 const isAction = (value) => actions.includes(value);
 const usage = [
@@ -14,6 +14,7 @@ const usage = [
     '       shinaps-skills validate-managed-config <file>',
     '       shinaps-skills managed <setup|run|status|reply|collect> (see managed --help)',
     '       shinaps-skills auto-update <enable|disable|status|check> codex',
+    '       shinaps-skills lint --checks <checks.json> --root <project> --out <result.json> -- <files...>',
     'Claude Code: /plugin marketplace add sh1n4ps/shinaps-skills',
     '             /plugin install shinaps@shinaps-skills',
 ].join('\n');
@@ -124,7 +125,7 @@ async function uninstall(installation, options) {
             return;
         }
         // auto-update.ts は check でこのモジュールを使う。相互 import を避けるため実行時に読み込む。
-        const { autoUpdate } = await import('./auto-update.js');
+        const { autoUpdate } = await import("./auto-update.js");
         await autoUpdate(['disable', 'codex'], options);
         await command(['plugin', 'remove', pluginId]);
         await command(['plugin', 'marketplace', 'remove', marketplaceName]);

package/dist/lib/linear-config.js

@@ -1,4 +1,4 @@
-import { validateConfig } from './config-validation.js';
+import { validateConfig } from "./config-validation.js";
 /** `.shinaps/linear.json` を同梱の契約で検証する。 */
 export async function validateLinearConfig(path) {
     await validateConfig(path, {

package/dist/lib/lint-plan.js

@@ -0,0 +1,173 @@
+/**
+ * `shinaps-skills lint` の入力・実行単位・結果の分類。ESLint を呼ばない純関数だけを置き、実行は lint.ts が行う。
+ *
+ * 規約 R × ファイル F の組を AI 照合から外してよいのは、次がすべて成り立つときだけ（docs/lint.md）。
+ * - R の検査の coverage が full（登録時の意味のレビューの結果。ここでは値を読むだけ）
+ * - その検査が F に適用されると ESLint が判定し、検査が属する実行単位が完了し、F に致命的な報告も
+ *   ruleId の無い報告も無い
+ * どれかが欠けた組は not-run にして AI へ回す。
+ */
+/** 検査を引く key。規約 id と、その規約の checks の中の位置で決まる。 */
+export const checkKey = (ruleId, index) => `${ruleId}#${index}`;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * 入力 JSON を検査の一覧にする。形が違えば throw し、呼び出し側は結果を書かずに失敗する（全組を AI へ）。
+ * 形だけを見る。ルール ID・options・glob の中身は検査せず、ESLint が拒否すればその検査だけが not-run になる。
+ */
+export function parseLintInput(raw) {
+    if (!isObject(raw) || !Array.isArray(raw.rules))
+        throw new Error('checks: expected { "rules": [...] }');
+    return {
+        rules: raw.rules.map((rule, ruleIndex) => {
+            const where = `checks: rules[${ruleIndex}]`;
+            if (!isObject(rule) || typeof rule.id !== 'string' || rule.id === '')
+                throw new Error(`${where}: expected a non-empty "id"`);
+            if (!Array.isArray(rule.checks))
+                throw new Error(`${where}: expected "checks" to be an array`);
+            return {
+                id: rule.id,
+                checks: rule.checks.map((check, checkIndex) => parseCheck(check, `${where}.checks[${checkIndex}]`)),
+            };
+        }),
+    };
+}
+function parseCheck(raw, where) {
+    if (!isObject(raw))
+        throw new Error(`${where}: expected an object`);
+    const { rule, options, files, coverage } = raw;
+    if (typeof rule !== 'string' || rule === '')
+        throw new Error(`${where}: expected a non-empty "rule"`);
+    if (options !== undefined && !Array.isArray(options))
+        throw new Error(`${where}: expected "options" to be an array`);
+    if (!Array.isArray(files) ||
+        files.length === 0 ||
+        !files.every((file) => typeof file === 'string' && file !== ''))
+        throw new Error(`${where}: expected "files" to be a non-empty array of globs`);
+    if (coverage !== 'full' && coverage !== 'partial')
+        throw new Error(`${where}: expected "coverage" to be "full" or "partial"`);
+    return { rule, options: options ?? [], files, coverage };
+}
+/** キーの順を揃えた JSON。同じ options を同じ文字列にして、実行単位でまとめるために使う。 */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (isObject(value))
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+            .join(',')}}`;
+    return JSON.stringify(value);
+}
+/**
+ * 検査を実行単位に分ける。同じルール・同じ options の検査は 1 つの設定にまとめ、同じルールで options が
+ * 違うものだけを別の単位にする（flat config では同じルールの設定は後勝ちで 1 つしか残らないため）。
+ * 型が要るルールは projectService を付けた単位に分ける。型の得られないファイルはその単位だけが fatal になり、
+ * 型なしの検査を巻き込まない。
+ * @param needsTypes ルール ID が型情報を要するか。解決できたルールについてだけ呼ぶ
+ */
+export function planUnits(bindings, needsTypes) {
+    const groups = new Map();
+    for (const binding of bindings) {
+        const key = `${binding.check.rule}\0${canonicalJson(binding.check.options)}`;
+        const group = groups.get(key);
+        if (group)
+            group.bindings.push(binding);
+        else
+            groups.set(key, {
+                rule: binding.check.rule,
+                options: binding.check.options,
+                bindings: [binding],
+            });
+    }
+    const units = new Map();
+    const variants = new Map();
+    for (const group of groups.values()) {
+        const typed = needsTypes(group.rule);
+        const variant = variants.get(group.rule) ?? 0;
+        variants.set(group.rule, variant + 1);
+        const id = `${typed ? 'typed' : 'syntax'}-${variant}`;
+        const unit = units.get(id) ?? { id, typed, rules: [] };
+        unit.rules.push(group);
+        units.set(id, unit);
+    }
+    return [...units.values()];
+}
+/**
+ * 組を分類する。検査は checkKey で引く。
+ * @param applied 検査ごとに、ESLint が適用すると判定したファイル（root からの相対パス）
+ * @param outcomeOf 検査ごとの、その検査が属する実行単位の結果。unusable の検査は含まない
+ * @param unusable 実行しなかった検査とその理由（この版に無いルール、ESLint が拒否した設定）
+ */
+export function classify(input) {
+    const pairs = [];
+    for (const rule of input.rules) {
+        if (rule.checks.length === 0)
+            continue;
+        for (const file of input.files) {
+            const findings = [];
+            const reasons = [];
+            let fullRan = false;
+            let anyRan = false;
+            for (const [index, check] of rule.checks.entries()) {
+                const key = checkKey(rule.id, index);
+                const unusable = input.unusable.get(key);
+                if (unusable !== undefined) {
+                    reasons.push(`${check.rule}: ${unusable}`);
+                    continue;
+                }
+                if (!input.applied.get(key)?.has(file))
+                    continue;
+                const outcome = input.outcomeOf.get(key);
+                if (outcome?.error !== undefined) {
+                    reasons.push(`${check.rule}: ${outcome.error}`);
+                    continue;
+                }
+                const report = outcome?.reports.get(file);
+                if (!report) {
+                    reasons.push(`${check.rule}: no result for the file`);
+                    continue;
+                }
+                const ruleless = report.messages.find((message) => message.ruleId === null);
+                if (report.fatal || ruleless) {
+                    reasons.push(`${check.rule}: ${ruleless?.message ?? 'fatal error'}`);
+                    continue;
+                }
+                anyRan = true;
+                if (check.coverage === 'full')
+                    fullRan = true;
+                for (const message of report.messages) {
+                    if (message.ruleId === check.rule)
+                        findings.push({
+                            rule: check.rule,
+                            line: message.line,
+                            column: message.column,
+                            message: message.message,
+                        });
+                }
+            }
+            const state = fullRan
+                ? findings.length > 0
+                    ? 'violation'
+                    : 'covered'
+                : anyRan
+                    ? 'partial'
+                    : 'not-run';
+            const pair = { ruleId: rule.id, file, state, findings: dedupe(findings) };
+            if (state === 'not-run')
+                pair.reason = reasons.length > 0 ? reasons.join('; ') : 'no check applies to the file';
+            pairs.push(pair);
+        }
+    }
+    return pairs;
+}
+// 同じルール・同じ options の検査を 1 規約が 2 つ持つと、同じ報告が 2 回集まるため 1 つにする。
+function dedupe(findings) {
+    const seen = new Set();
+    return findings.filter((finding) => {
+        const key = `${finding.rule}:${finding.line}:${finding.column}:${finding.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/lib/lint-rules.js

@@ -0,0 +1,52 @@
+/**
+ * Promise の executor が受け取る resolve / reject を、executor の外から使うために executor 内で別の場所へ
+ * 代入する書き方（deferred promise）を報告する。`Promise.withResolvers()` で書ける。
+ * 代入先は変数・プロパティを問わない。resolve / reject を値として渡す呼び出し（`setResolve(resolve)`）や、
+ * 包んだ関数の代入（`done = () => resolve()`）は報告しない（意図の判定に構文以上の情報が要るため）。
+ */
+const preferPromiseWithResolvers = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Create deferred promises with Promise.withResolvers instead of leaking the executor callbacks',
+        },
+        messages: {
+            leaked: "Promise executor's {{name}} is assigned to be used outside the executor. Use Promise.withResolvers().",
+        },
+        schema: [],
+    },
+    create(context) {
+        // 名前だけで判定すると、executor の内側の関数が同じ名前の引数を持つ場合を取り違える。
+        // 右辺を scope で解決し、それを定義した関数が、祖先の `new Promise(...)` の第 1 引数そのものかを確かめる。
+        return {
+            AssignmentExpression(node) {
+                if (node.right.type !== 'Identifier')
+                    return;
+                const definition = findVariable(context.sourceCode.getScope(node), node.right.name)
+                    ?.defs[0];
+                if (definition?.type !== 'Parameter')
+                    return;
+                const leaksExecutorParameter = context.sourceCode
+                    .getAncestors(node)
+                    .some((ancestor) => ancestor.type === 'NewExpression' &&
+                    ancestor.callee.type === 'Identifier' &&
+                    ancestor.callee.name === 'Promise' &&
+                    ancestor.arguments[0] === definition.node);
+                if (leaksExecutorParameter)
+                    context.report({ node, messageId: 'leaked', data: { name: node.right.name } });
+            },
+        };
+    },
+};
+function findVariable(scope, name) {
+    for (let current = scope; current; current = current.upper) {
+        const variable = current.set.get(name);
+        if (variable)
+            return variable;
+    }
+    return undefined;
+}
+export const shinapsPlugin = {
+    meta: { name: 'shinaps' },
+    rules: { 'prefer-promise-with-resolvers': preferPromiseWithResolvers },
+};

package/dist/lib/lint.js

@@ -0,0 +1,233 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { checkKey, classify, parseLintInput, planUnits, } from "./lint-plan.js";
+import { shinapsPlugin } from "./lint-rules.js";
+import { errorMessage } from "./fs.js";
+const USAGE = 'Usage: shinaps-skills lint --checks <checks.json> --root <project> --out <result.json> -- <files...>';
+/**
+ * `shinaps-skills lint`: 規約の検査を、プロジェクトの設定を使わずに ESLint の Node API で実行し、
+ * 規約 × ファイルの組を分類して result.json に書く。プロジェクトの lint 設定・script・node_modules の
+ * パッケージは読み込まない（overrideConfigFile: true、プラグインはこのパッケージの依存から渡す）。
+ * 対象ファイルへは書き込まない。
+ */
+export async function lint(args) {
+    const options = parseArgs(args);
+    const input = parseLintInput(JSON.parse(await readFile(options.checks, 'utf8')));
+    const result = await runLint(input, options.root, options.files);
+    await writeFile(options.out, `${JSON.stringify(result, null, 2)}\n`);
+    const counts = Object.fromEntries(['covered', 'violation', 'partial', 'not-run'].map((state) => [
+        state,
+        result.pairs.filter((pair) => pair.state === state).length,
+    ]));
+    console.log(`Shinaps lint: ${JSON.stringify(counts)} → ${options.out}`);
+}
+function parseArgs(args) {
+    const separator = args.indexOf('--');
+    const flags = separator === -1 ? args : args.slice(0, separator);
+    const files = separator === -1 ? [] : args.slice(separator + 1);
+    const value = (name) => {
+        const index = flags.indexOf(name);
+        const found = index === -1 ? undefined : flags[index + 1];
+        if (!found)
+            throw new Error(`${name} is required. ${USAGE}`);
+        return found;
+    };
+    return { checks: value('--checks'), root: resolve(value('--root')), out: value('--out'), files };
+}
+/**
+ * @param root 対象プロジェクトのルート（絶対パス）
+ * @param files 対象ファイル。root からの相対パスか絶対パス。結果では root からの相対パス（区切りは `/`）で表す
+ */
+export async function runLint(input, root, files) {
+    const { ESLint } = await import('eslint');
+    const registry = await loadRegistry();
+    const relativeFiles = [...new Set(files.map((file) => toRelative(root, file)))];
+    const newESLint = (overrideConfig) => new ESLint({
+        cwd: root,
+        overrideConfigFile: true,
+        overrideConfig,
+        allowInlineConfig: false,
+        // 削除済みなどで存在しないファイルを渡しても単位全体を失敗にせず、そのファイルを「結果なし」
+        // (not-run) にするため。
+        errorOnUnmatchedPattern: false,
+        // 渡すのはファイルだけ。`src/*.ts` のような名前のファイルを glob として展開し、渡していない
+        // ファイルまで検査しないため。
+        globInputPaths: false,
+    });
+    const needsTypes = (rule) => 
+    // ESLint の型の docs には requiresTypeChecking が無い (typescript-eslint が付ける独自の項目)。
+    registry.rules.get(rule)?.meta?.docs
+        ?.requiresTypeChecking === true;
+    // 検査が F に適用されるかは ESLint だけが判定する。その検査の設定だけを入れたインスタンスで
+    // calculateConfigForFile を呼び、ルールが有効なら適用される。glob の解釈を CLI 側で再現しない。
+    // ESLint が設定（不正な options など）を拒否した検査は、ここで not-run にして実行単位に入れない。
+    // 単位に入れると、同じ単位の他の検査まで実行できなくなるため。
+    const unusable = new Map();
+    const applied = new Map();
+    const bindings = [];
+    for (const rule of input.rules) {
+        for (const [index, check] of rule.checks.entries()) {
+            const key = checkKey(rule.id, index);
+            if (!registry.rules.has(check.rule)) {
+                unusable.set(key, 'unsupported rule in this version of @shinaps/skills');
+                continue;
+            }
+            const binding = { ruleId: rule.id, index, check };
+            const single = newESLint(unitConfig(registry, root, needsTypes(check.rule), [
+                { rule: check.rule, options: check.options, bindings: [binding] },
+            ]));
+            try {
+                const hits = new Set();
+                for (const file of relativeFiles) {
+                    if (isActive(await single.calculateConfigForFile(resolve(root, file)), check.rule))
+                        hits.add(file);
+                }
+                applied.set(key, hits);
+                bindings.push(binding);
+            }
+            catch (error) {
+                unusable.set(key, oneLine(error));
+            }
+        }
+    }
+    const outcomeOf = new Map();
+    const units = [];
+    for (const unit of planUnits(bindings, needsTypes)) {
+        const unitBindings = unit.rules.flatMap((planned) => planned.bindings);
+        const targets = [
+            ...new Set(unitBindings.flatMap((binding) => [
+                ...(applied.get(checkKey(binding.ruleId, binding.index)) ?? []),
+            ])),
+        ];
+        const outcome = await runUnit(unit, targets);
+        for (const binding of unitBindings)
+            outcomeOf.set(checkKey(binding.ruleId, binding.index), outcome);
+        units.push({
+            id: unit.id,
+            typed: unit.typed,
+            rules: unit.rules.map((planned) => planned.rule),
+            // ESLint が結果を返したファイルの数。単位のエラーや存在しないファイルでは、渡した数より少なくなる。
+            fileCount: outcome.reports.size,
+            ...(outcome.error === undefined ? {} : { error: outcome.error }),
+        });
+    }
+    async function runUnit(unit, targets) {
+        // 渡すファイルが無ければ実行しない。ファイルを省くと ESLint は cwd 配下を全部検査するため。
+        if (targets.length === 0)
+            return { reports: new Map() };
+        try {
+            const results = await newESLint(unitConfig(registry, root, unit.typed, unit.rules)).lintFiles(targets.map((file) => resolve(root, file)));
+            const reports = new Map();
+            for (const result of results) {
+                reports.set(toRelative(root, result.filePath), {
+                    fatal: result.fatalErrorCount > 0,
+                    messages: result.messages.map((message) => ({
+                        ruleId: message.ruleId,
+                        line: message.line,
+                        column: message.column,
+                        message: message.message,
+                    })),
+                });
+            }
+            return { reports };
+        }
+        catch (error) {
+            return { error: oneLine(error), reports: new Map() };
+        }
+    }
+    return {
+        root,
+        units,
+        pairs: classify({ rules: input.rules, files: relativeFiles, applied, outcomeOf, unusable }),
+    };
+}
+// ESLint の設定エラーは複数行で、理由が 2 行目以降にあるため、1 行にまとめて結果に残す。
+const oneLine = (error) => errorMessage(error)
+    .replace(/\s*\n\s*/g, ' ')
+    .trim();
+function toRelative(root, file) {
+    const absolute = isAbsolute(file) ? file : resolve(root, file);
+    return relative(root, absolute).split(sep).join('/');
+}
+function isActive(config, rule) {
+    const entry = config?.rules?.[rule];
+    const severity = Array.isArray(entry) ? entry[0] : entry;
+    return severity !== undefined && severity !== 0 && severity !== 'off';
+}
+async function loadRegistry() {
+    const [{ builtinRules }, tseslint, vue, vueParser] = await Promise.all([
+        import('eslint/use-at-your-own-risk'),
+        import('typescript-eslint'),
+        import('eslint-plugin-vue'),
+        import('vue-eslint-parser'),
+    ]);
+    // typescript-eslint と eslint-plugin-vue が公開する型は ESLint の Plugin・Parser・RuleModule の型と
+    // 細部が一致しない (どちらも実行時は ESLint の API に従う)。flat config に渡すために ESLint の型にする。
+    const plugins = {
+        '@typescript-eslint': tseslint.default.plugin,
+        vue: vue.default,
+        shinaps: shinapsPlugin,
+    };
+    const rules = new Map(builtinRules);
+    for (const [prefix, plugin] of Object.entries(plugins)) {
+        for (const [name, rule] of Object.entries(plugin.rules ?? {}))
+            rules.set(`${prefix}/${name}`, rule);
+    }
+    return {
+        plugins,
+        rules,
+        parsers: {
+            typescript: tseslint.default.parser,
+            vue: vueParser.default,
+        },
+    };
+}
+const TS_FILES = ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'];
+// 検査の対象にする拡張子。ESLint は `src/**` のように全てのファイルに一致する glob だけではファイルを検査の
+// 対象にしないので、拡張子を指定したパターンを両方の単位に置く。単位の種類で適用範囲が変わらないよう、
+// 型付き・型なしで同じ一覧を使う。
+const LINTED_FILES = [...TS_FILES, '**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs', '**/*.vue'];
+/**
+ * 実行単位の設定。parser は拡張子ごとの設定オブジェクトで指定し、ルールは検査の glob の和に付ける。
+ * 型付きの単位は、対象の全てのファイルを projectService 付きの typescript-eslint で読む。型の得られない
+ * ファイル (tsconfig に含まれない JS、Vue など) はそのファイルだけが fatal (not-run) になる。JS を ESLint
+ * の既定の parser で読むと、型を要求するルールが単位全体を例外で止め、他の検査を巻き込むため。
+ * 型付きの単位では Vue を扱わない (vue-eslint-parser と projectService の組み合わせは使っていない)。
+ */
+function unitConfig(registry, root, typed, rules) {
+    const parsers = typed
+        ? [
+            {
+                files: LINTED_FILES,
+                languageOptions: {
+                    parser: registry.parsers.typescript,
+                    parserOptions: { projectService: true, tsconfigRootDir: root },
+                },
+            },
+        ]
+        : [
+            { files: LINTED_FILES },
+            // 既定の parser は JSX を読まないので、.jsx では JSX を有効にする (無いと常に parse error で not-run)。
+            {
+                files: ['**/*.jsx'],
+                languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+            },
+            { files: TS_FILES, languageOptions: { parser: registry.parsers.typescript } },
+            {
+                files: ['**/*.vue'],
+                languageOptions: {
+                    parser: registry.parsers.vue,
+                    parserOptions: { parser: registry.parsers.typescript, sourceType: 'module' },
+                },
+            },
+        ];
+    return [
+        ...parsers,
+        ...rules.map((planned) => ({
+            files: [...new Set(planned.bindings.flatMap((binding) => binding.check.files))],
+            plugins: registry.plugins,
+            // options は JSON の配列 (unknown[]) で、ESLint の RuleEntry は要素の型を持たないので型だけを合わせる。
+            rules: { [planned.rule]: ['error', ...planned.options] },
+        })),
+    ];
+}

package/dist/lib/lock.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { errorCode } from './fs.js';
+import { errorCode } from "./fs.js";
 /**
  * `<directory>/update.lock` を保持したまま `work` を実行する。ロックはディレクトリで、保持者の pid を
  * `pid` ファイルに記録する。保持者が存在しないロックは置き換える。保持者が生きているか pid をまだ読め

package/dist/lib/managed-config.js

@@ -1,4 +1,4 @@
-import { validateConfig } from './config-validation.js';
+import { validateConfig } from "./config-validation.js";
 /** `.shinaps/managed.json` を同梱の契約で検証し、内容を返す。 */
 export async function validateManagedConfig(path) {
     return (await validateConfig(path, {

package/dist/lib/managed-session.js

@@ -1,9 +1,9 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { readJson, readJsonIfExists, writeFileAtomic } from './fs.js';
-import { withLock } from './lock.js';
-import { filesBeta, managedBeta } from './managed-ant.js';
+import { readJson, readJsonIfExists, writeFileAtomic } from "./fs.js";
+import { withLock } from "./lock.js";
+import { filesBeta, managedBeta } from "./managed-ant.js";
 export const staffings = ['LITE', 'BASIC', 'ULTRA'];
 export const permissions = ['commit', 'push', 'draft_pr'];
 const leadKey = './agents/shinaps-dev-managed-cc.md';

package/dist/lib/managed-setup.js

@@ -1,10 +1,10 @@
 import { createHash } from 'node:crypto';
 import { lstat, mkdir, readdir, readFile, rm } from 'node:fs/promises';
 import { dirname, join, relative, sep } from 'node:path';
-import { errorCode, readJsonIfExists, readTextIfExists, writeFileAtomic } from './fs.js';
-import { withLock } from './lock.js';
-import { managedTemplatePath } from './layout.js';
-import { managedBeta } from './managed-ant.js';
+import { errorCode, readJsonIfExists, readTextIfExists, writeFileAtomic } from "./fs.js";
+import { withLock } from "./lock.js";
+import { managedTemplatePath } from "./layout.js";
+import { managedBeta } from "./managed-ant.js";
 /** 共通定義の 3 ディレクトリ。`definitions/` には、これと `claude-lock.json` 以外を置かない。 */
 const definitionDirs = ['agents', 'environments', 'skills'];
 const lockName = 'claude-lock.json';

package/dist/lib/managed.js

@@ -1,11 +1,11 @@
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { errorMessage } from './fs.js';
-import { managedAccountDir, managedRoot, packageRoot } from './layout.js';
-import { antCommand } from './managed-ant.js';
-import { validateManagedConfig } from './managed-config.js';
-import { collectOutputs, permissions, replySession, runSession, sessionStatus, staffings, } from './managed-session.js';
-import { setupAccount } from './managed-setup.js';
+import { errorMessage } from "./fs.js";
+import { managedAccountDir, managedRoot, packageRoot } from "./layout.js";
+import { antCommand } from "./managed-ant.js";
+import { validateManagedConfig } from "./managed-config.js";
+import { collectOutputs, permissions, replySession, runSession, sessionStatus, staffings, } from "./managed-session.js";
+import { setupAccount } from "./managed-setup.js";
 const managedUsage = [
     'Usage: shinaps-skills managed setup --account <name> [--account <name> ...] [--apply]',
     '       shinaps-skills managed run <managed.json> --account <name> --base <branch> --base-sha <sha> --head <branch> --staffing <LITE|BASIC|ULTRA> --allow <none|commit,push,draft_pr> --budget-cents <n> --task-file <file> [--verify <command>] [--author "<name> <email>"] [--title <title>] [--claude-md <file>]',

package/dist/lib/transaction.js

@@ -1,8 +1,8 @@
 import { mkdir, rm, rename, cp } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
-import { managedAgent, marketplaceName, payloadDir, pluginId, statePath } from './layout.js';
-import { errorCode, errorMessage, readJsonIfExists, readTextIfExists, writeFileAtomic, } from './fs.js';
+import { managedAgent, marketplaceName, payloadDir, pluginId, statePath } from "./layout.js";
+import { errorCode, errorMessage, readJsonIfExists, readTextIfExists, writeFileAtomic, } from "./fs.js";
 /** エージェント内容の sha256。state.json と journal の `nextHashes` はこの形式で記録する。 */
 export const digest = (text) => createHash('sha256').update(text).digest('hex');
 /** 配布物を Codex に登録する。install と restore で同じ手順を使う。 */

package/docs/development.md

@@ -7,7 +7,7 @@
 - Claude 版: `plugins/shinaps-claude/`、marketplace は `.claude-plugin/marketplace.json`
 - Codex 版: `plugins/shinaps-codex/`、marketplace は `.agents/plugins/marketplace.json`。サブエージェントは `plugins/shinaps-codex/agents/`
 - Claude Managed Agents 版: 両 plugin の `managed-agents/`。plugin と一緒に配布され、npm パッケージの `plugins/` にも含まれる
-- 配布 CLI: ソースは `bin/skills.ts` と `lib/*.ts`。`npm run build`（`tsc`）で `dist/` に JS を出力し、npm にはそれを配布する。Node.js は `node_modules` 配下の `.ts` に型除去を適用しないため、ソースのままは配布できない。checkout では型除去で直接実行するので、`enum` など型除去で消せない構文は使わない（`tsconfig.json` の `erasableSyntaxOnly`）
+- 配布 CLI: ソースは `bin/skills.ts` と `lib/*.ts`。規約の機械検査（`lint`）は ESLint の Node API を使い、仕組みと同梱ルールの追加手順は [規約の機械検査](lint.md) にある。TypeScript は typescript-eslint が対応する 6 系を実行時の依存に持ち、開発用の `tsc` も同じ版を使う（typescript-eslint が 7 に対応したら上げる）。`npm run build`（`tsc`）で `dist/` に JS を出力し、npm にはそれを配布する。Node.js は `node_modules` 配下の `.ts` に型除去を適用しないため、ソースのままは配布できない。checkout では型除去で直接実行するので、`enum` など型除去で消せない構文は使わない（`tsconfig.json` の `erasableSyntaxOnly`）
 
 品質基準とプロジェクト設定の方針は両版で揃え、クライアント固有の実行手順とエージェントの形式は別々に管理する。スキルを追加・変更したら各版への適用可否を判断する。
 

package/docs/install.md

@@ -4,7 +4,7 @@ Claude Code 版の更新と、Codex 版の導入・更新・削除・macOS で
 
 ## 導入・更新・削除
 
-Node.js 22 以上と、`plugin marketplace add` / `plugin add` に対応した Codex CLI が必要です。Codex のスキルだけを使う場合、Claude Code のインストールは不要です。
+Node.js 22.13 以上の 22 系または 24 以上と、`plugin marketplace add` / `plugin add` に対応した Codex CLI が必要です。Codex のスキルだけを使う場合、Claude Code のインストールは不要です。
 
 ```sh
 npx @shinaps/skills@latest install codex
@@ -23,10 +23,10 @@ npx @shinaps/skills@latest recover codex
 
 ## 配布 CLI
 
-設定の検証（`validate-linear-config`・`validate-managed-config`）と Managed Agents の操作（`managed`）には、配布 CLI `shinaps-skills` を使います。CLI は plugin に含まれないため、利用中のスキルと同じ版を導入します。
+設定の検証（`validate-linear-config`・`validate-managed-config`）、Managed Agents の操作（`managed`）、規約の機械検査（`lint`、[規約の機械検査](lint.md)）には、配布 CLI `shinaps-skills` を使います。CLI は plugin に含まれないため、利用中のスキルと同じ版を導入します。
 
 ```sh
-npm install -g @shinaps/skills@0.43.0
+npm install -g @shinaps/skills@0.44.0
 shinaps-skills --version
 ```
 

package/docs/lint.md

@@ -0,0 +1,71 @@
+# 規約の機械検査（`shinaps-skills lint`）
+
+Shinaps AIの規約が持つ機械検査（`checks`）を手元で実行し、規約×ファイルの組ごとに、AI照合を省けるかを判定するCLIです。エージェント向けの使い方は plugin の `references/lint.md` にあります。
+
+## 前提と保証
+
+- プロジェクトの変更は要りません。プロジェクトのlint設定（`eslint.config.*`・`.oxlintrc.json`・`bunfig.toml` など）・`package.json` のscript・`node_modules` のパッケージは読み込みません。ESLintのNode APIを `overrideConfigFile: true` で使い、パーサーとプラグインはこのパッケージの依存から渡します。読むのは対象ファイルと、型情報を使うルールのための `tsconfig.json`・型宣言だけです（実行はしません）。
+- 対象ファイルへ書き込みません（自動修正はしません）。結果はローカルのファイルに書き、サーバーへは送りません。
+- プロジェクトの `eslint-disable` コメントでは検査を抑止しません（`allowInlineConfig: false`）。プロジェクトの都合の例外は、指摘を確認する側で扱います。
+- 組をAI照合から外してよいのは、coverage が `full` の検査が、ESLintの判定でそのファイルに適用され、検査の実行単位が完了し、そのファイルに致命的な報告もruleIdの無い報告も無いときだけです。それ以外の組は `not-run`（または `partial`）として返し、合格にしません。coverage は検査を登録したときの判断で、このCLIは値を読むだけです。
+
+## 使い方
+
+```sh
+shinaps-skills lint --checks <checks.json> --root <project> --out <result.json> -- <files...>
+```
+
+- `--checks`・`--out` のパスは、コマンドを実行したディレクトリが基準です。
+- `--checks`: `{ "rules": [{ "id": "<規約id>", "checks": [{ "rule": "...", "options": [...], "files": ["**/*.ts"], "coverage": "full" }] }] }`。形が違えば何も書かずに終了コード1で終わります。
+- `--root`: 対象プロジェクトのルート。ESLintの `cwd` と、結果のパスの基準になります。
+- `<files...>`: 対象ファイル（`--root` からの相対パスか絶対パス）。どの検査も適用されないファイルはESLintに渡しません。渡すファイルが無ければESLintを起動しません（ファイルを省くとESLintはルート配下を全て検査するため）。
+- `--out`: 結果のJSON。
+
+結果:
+
+```json
+{
+  "root": "/path/to/project",
+  "units": [{ "id": "syntax-0", "typed": false, "rules": ["@typescript-eslint/method-signature-style"], "fileCount": 3 }],
+  "pairs": [
+    { "ruleId": "<規約id>", "file": "src/a.ts", "state": "covered", "findings": [] },
+    { "ruleId": "<規約id>", "file": "src/b.ts", "state": "violation", "findings": [{ "rule": "@typescript-eslint/method-signature-style", "line": 2, "column": 3, "message": "..." }] },
+    { "ruleId": "<規約id>", "file": "tests/c.ts", "state": "not-run", "reason": "...", "findings": [] }
+  ]
+}
+```
+
+| state | 意味 | 照合 |
+| --- | --- | --- |
+| `covered` | `full` の検査が実行され、違反が無い | 外す |
+| `violation` | `full` の検査が実行され、指摘がある（同じ規約の `partial` の検査の指摘を含む） | 外し、`findings` を指摘にする |
+| `partial` | `partial` の検査だけが実行された | 残し、`findings` も指摘にする |
+| `not-run` | 実行していない（`reason` に理由） | 残す |
+
+## 実行の仕組み
+
+1. 各検査のルールを、ESLint core・`@typescript-eslint`・`vue`・同梱の `shinaps` から引きます。この版に無いルールの検査は `not-run` になり、他の検査は止まりません。
+2. 検査ごとに、その検査の設定だけを入れたESLintで `calculateConfigForFile` を呼び、ルールが有効なファイルを適用先にします。globの解釈はESLintだけが行います。ESLintが設定を拒否した検査（不正なoptionsなど）は、ここで `not-run` になります。
+3. 同じルール・同じoptionsの検査は1つの設定にまとめ、同じルールでoptionsが違うものだけを別の実行単位にします。型情報を使うルール（`meta.docs.requiresTypeChecking`）は `projectService` を使う単位に分けます。この単位は全てのファイルを typescript-eslint で読み、型の得られないファイル（`tsconfig.json` に含まれないTS・JS、Vue）はそのファイルだけが `not-run` になります。型なしの検査と、他のファイルの型付きの検査は影響を受けません。型情報を使うルールはVueのファイルでは実行できません。
+4. 実行単位ごとに `lintFiles` を1回呼び、組を分類します。指摘は、ESLintがそのファイルに適用すると判定した検査の規約にだけ付けます。
+
+## 同梱ルール
+
+| ルールID | 内容 | 型情報 |
+| --- | --- | --- |
+| `shinaps/prefer-promise-with-resolvers` | Promiseのexecutorが受け取る `resolve`・`reject` を、executorの外で使うために変数・プロパティへ代入する書き方（deferred promise）を報告する。`Promise.withResolvers()` で書ける。包んだ関数の代入や、値として渡す呼び出しは報告しない | 不要 |
+
+### 同梱ルールの追加
+
+規約の検査に既存のルールが使えないとき、レビュー済みでテスト済みのルールをこのパッケージに同梱します。サーバーにはルールのIDとoptionsだけを保存し、コードは配布しません。同梱していないルールは、実装・テスト・レビュー・リリースを経るまで使えません（それまでは、その規約はAI照合のままです）。
+
+1. `lib/lint-rules.ts` にルールを足し、`shinapsPlugin.rules` に登録します。IDは意味を変えずに使い続けます（規約の検査はIDで保存され、登録時の意味のレビューがその挙動を前提にするため）。意味が変わるなら別のIDにします。型情報を使うルールには `meta.docs.requiresTypeChecking: true` を付けます（付けないと型なしの実行単位に入り、その単位の検査が全て `not-run` になります）。
+2. `test/lint.test.ts` に、ESLintの `RuleTester` で報告する例・しない例を書きます。規約の good・bad の例と、誤って報告しやすい形（同じ名前の別の変数など）を含めます。型情報を使わないルールは、型情報なしの `RuleTester` で動くことがそのまま確認になります。型情報を使うルールは、`languageOptions.parserOptions` に `projectService` を付けた `RuleTester` で試します。
+3. この文書の「同梱ルール」の表に追加し、通常の変更と同じくレビュー・リリースします。
+4. 規約に検査を付けるのはリリースの後です。規約の全文を読んで coverage を決めます（plugin の `references/lint.md`）。
+
+実例: `shinaps/prefer-promise-with-resolvers`（`lib/lint-rules.ts`）。右辺の識別子をscopeで解決し、Promiseのexecutorの引数そのものかを確かめることで、内側の関数の同じ名前の引数を取り違えないようにしています。テストは `test/lint.test.ts` の末尾にあります。
+
+## 依存
+
+ESLint・typescript-eslint・TypeScript・vue-eslint-parser・eslint-plugin-vue を完全一致の版で依存に持ちます（パッケージの導入が約50MB増えます）。typescript-eslint は TypeScript 7 に対応していないため、TypeScript は6系です（開発用の `tsc` も同じ版を使います）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shinaps/skills",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Install Shinaps AI workflows and custom agents for Codex",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=22"
+    "node": "^22.13.0 || >=24"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -36,10 +36,14 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.15",
-    "@types/node": "^26.6.4",
-    "typescript": "^7.0.2"
+    "@types/node": "^26.6.4"
   },
   "dependencies": {
-    "ajv": "^8.20.0"
+    "ajv": "^8.20.0",
+    "eslint": "10.14.0",
+    "eslint-plugin-vue": "10.12.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.1",
+    "vue-eslint-parser": "10.4.1"
   }
 }

package/plugins/shinaps-claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shinaps",
   "description": "Shinaps AIの開発ワークフロー。プロジェクトの指示から条件を読み、調査・設計・実装・簡素化・レビュー・コミット・PR・リリースとLinearでの開発進行を支援する。",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "author": {
     "name": "shinaps"
   },

package/plugins/shinaps-claude/references/linear/configuration.md

@@ -4,7 +4,7 @@
 
 ## 検証CLIと契約版
 
-利用中のskillとCLIの版を確認し、0.43.0のskillには同じ版のnpm CLIを導入する（`npm install -g @shinaps/skills@0.43.0`）。pluginだけにはCLIは含まれない。導入・更新が必要ならその権限を確認し、検証のたびに `npx latest` を取得しない。
+利用中のskillとCLIの版を確認し、0.44.0のskillには同じ版のnpm CLIを導入する（`npm install -g @shinaps/skills@0.44.0`）。pluginだけにはCLIは含まれない。導入・更新が必要ならその権限を確認し、検証のたびに `npx latest` を取得しない。
 
 0.35.0から通常設定の `review_flow.mode` に `ask` を受理する。`config_version` は2のままで、既存のauto・manualの設定は変更不要。0.33.0〜0.34.xのCLIと `$schema` のURLは `ask` を拒否するため、`ask` を使う設定では `$schema` も0.35.0以降のURLにする。
 

package/plugins/shinaps-claude/references/lint.md

@@ -0,0 +1,34 @@
+# 規約の機械検査（Shinaps lint）
+
+Shinaps AIの規約は、機械検査（`checks`）を持てる。検査は配布CLI `shinaps-skills lint` が、プロジェクトのlint設定・script・依存を使わずに手元で実行する。プロジェクトの変更は要らない。対象のコード・差分・結果はサーバーへ送らない。CLIの入出力と同梱ルールの追加手順は、配布パッケージの `docs/lint.md` にある。
+
+検査で照合を省いてよいのは、静的に保証できた組（規約×ファイル）だけ。未実行・対象外・エラー・一部だけの検査は合格にせず、AI照合に回す。
+
+## 照合で使う
+
+[Shinaps規約の取得](rules.md)で全文を取得した後、照合の担当へ渡す前に行う。
+
+1. 全文の `checks` を持つ規約を、`{ "rules": [{ "id": "<規約id>", "checks": [<全文のchecksのまま>] }] }` の形で作業記録の下（例: `.shinaps/work/<作業>/lint-checks.json`）に書く。checksを書き換えない。持つ規約が無ければこの節を省く。
+2. 対象ファイル（照合の対象として確定したもの。削除されたファイルを除く）を付けて1回実行する。
+
+   ```sh
+   shinaps-skills lint --checks <lint-checks.json> --root <リポジトリのルート> --out <lint-result.json> -- <対象ファイル...>
+   ```
+
+   コマンドが無い、終了コードが0でない、または結果を読めないときは、全ての規約をAI照合に回し、理由を報告する。CLIは利用中のスキルと同じ版を使う。
+3. 結果の `pairs` は規約×ファイルの組ごとに状態を持つ。
+   - `covered`: 全体を検査する検査（coverage `full`）が実行され、違反が無い。この組は担当の照合から外す。
+   - `violation`: 全体を検査する検査が実行され、指摘がある（同じ規約の一部だけを検査する検査の指摘を含む）。照合から外し、`findings` を指摘にする。
+   - `partial`: 一部だけを検査する検査だけが実行された。`findings` を指摘にし、規約はそのファイルの照合に残す（担当にはlintの指摘も渡す）。
+   - `not-run`: 実行していない（対象外、この版に無いルール、ESLintが設定を拒否した、型が得られない、致命的な報告など）。照合に残し、`reason` を記録する。
+4. lint由来の指摘は、根拠に規約idとルールID（`findings[].rule`）を付けて集約に入れる。誤報告がありうるので自動修正にせず、メインがその位置を読んで確認してから扱う。
+5. 報告に、状態ごとの組の数、`not-run` の理由、`units[].error` を書く。照合から外した組を「AIが照合した」と書かない。
+
+## 検査を登録・更新する
+
+[Shinaps規約の書き方](rule-writing.md)で書き込む規約に、検査を付けられるかを判断する。
+
+- **使えるルール**: ESLint core、`@typescript-eslint/*`（型情報を使うものを含む）、`vue/*`、同梱の `shinaps/*`（`docs/lint.md` の一覧）。版によって違うので、同じ版のCLIで確かめる。使えるルールが無い規約には検査を付けない（AI照合のまま）。同梱ルールの追加は `docs/lint.md` の手順で別の作業として提案する。
+- **coverageの判断**: 規約の全文（scope・labelsを含み、更新では更新後の全文）と、検査の `rule`・`options`・`files` を照らす。`files` の範囲で、規約が求めることへの違反をこのルールが全て報告すると言えるときだけ `full`、見逃しが一つでもありうれば `partial`。lintが規約より広く報告する（例外も報告する）ことは `full` の妨げにならない（指摘はメインが確認する）。例で通ることは根拠にならない。
+- **補助の確認**: 規約のgood・badの例を一時ディレクトリにファイルとして書き、同じ入口で実行して、badで報告され、goodで報告されないことを確かめる。対象プロジェクトのコードを写さない。
+- **書き込み**: `record_rule`・`update_rule` の `checks` に渡す。一括の `record_rules` は `checks` を受け取らない（付けると呼出し全体が入力エラーになる）ので、検査は登録後に `update_rule` で付ける。`update_rule` は配列ごと置換し、`[]` で外す。検査を持つ規約の内容（出典以外）を変える更新では、更新後の全文で検査を見直し、同じ要求で `checks` を渡す。渡さないと `CHECKS_REQUIRED` で保存されない。見直した結果が同じなら同じ配列を渡す。

package/plugins/shinaps-claude/references/rule-writing.md

@@ -34,6 +34,10 @@ Shinaps AIへ個人規約を登録・更新するときの書き方。短さそ
 
 結果は候補ごとに、比べた既存の規約のidまたは相手の候補、未確定ならその旨、取得の条件、未完了の範囲と返らない範囲を添えて報告する。
 
+## 機械検査
+
+coding の規約は、使えるlintのルールで検査できるかを判断し、できるものには `checks` を付ける。coverageの決め方・補助の確認・書き込みと、検査を持つ規約の内容を変えるときの見直しは[規約の機械検査](lint.md)の「検査を登録・更新する」に従う。
+
 ## 項目の役割
 
 各項目は役割が重ならないようにし、同じ内容を言い換えて繰り返さない。

package/plugins/shinaps-claude/references/rules.md

@@ -70,7 +70,7 @@ Shinaps AIのMCPから規約を取得する手順。取得は呼出し元（メ
 
 ## 担当へ渡す
 
-全文は取得した応答の単位で、続きのバッチとして渡す。1回の依頼に全件をまとめない。担当には読み終えた規約のidを報告させ、報告の無い範囲は同じ担当へ戻す。
+`checks` を持つ規約がある照合では、渡す前に[規約の機械検査](lint.md)の「照合で使う」を行い、照合から外す組を決める。全文は取得した応答の単位で、続きのバッチとして渡す。1回の依頼に全件をまとめない。担当には読み終えた規約のidを報告させ、報告の無い範囲は同じ担当へ戻す。
 
 ## 照合結果に書くこと
 

package/plugins/shinaps-claude/skills/refine/SKILL.md

@@ -33,7 +33,7 @@ shinaps-ai サーバは git / file / AI 推論を一切呼ばない。すべて
 メインスレッド (あなた) は **オーケストレータ** に徹する:
 
 1. 対象ファイル集合の確定、規約カタログの集約 (Step 0-1)
-2. 規約・対象ファイルを担当へ渡せる形に整理する (Step 2)
+2. 機械検査で静的に保証できた組を照合から外し、規約・対象ファイルを担当へ渡せる形に整理する (Step 2)
 3. Opus / medium 1体を起動し、全対象を照合する (Step 3)
 4. 返ってきた findings を集約 → 変更箇所 / 既存箇所で振り分け (Step 4-5)
 
@@ -68,6 +68,8 @@ shinaps-ai サーバは git / file / AI 推論を一切呼ばない。すべて
 
 ## Step 2. 共通の照合対象を準備する
 
+取得した rule 全文に `checks` を持つ規約があれば、先に [規約の機械検査](../../references/lint.md) の「照合で使う」を行う。`covered`・`violation` の組（規約×ファイル）はそのファイルについて担当の照合対象から外し、`violation`・`partial` の findings は lint 由来の指摘として Step 4 に加える。担当には、ファイルごとに照合から外した規約の id を伝え、`partial` の組には lint の指摘を添える。
+
 取得した rule 全文と関連する AGENTS.md / CLAUDE.md / docs、対象ファイル、変更範囲を担当へ渡す。対象が大きい場合は関連するファイルをまとめてバッチに分け、対象全体の一覧を維持する。カテゴリ数やバッチ数を起動するエージェント数に置き換えない。
 
 ## Step 3. Opus 1体で照合する
@@ -139,6 +141,7 @@ shinaps-ai サーバは git / file / AI 推論を一切呼ばない。すべて
 - **scope 整合**: 同じ箇所の `scope` がバッチ間で異なる場合は実際の変更範囲を確認して判断し、不明なら `pre-existing` とする
 - **優先度整列**: Violation → Improvement → Question の順に並べ、Violation 内は影響範囲が大きいものから
 - **注意**: Info レベルは元々含まれない前提だが、agent 出力に混じっていたら破棄する
+- **lint 由来の指摘**: 根拠は規約 id とルール ID。メインが該当位置を読んで違反か確かめてから他の finding と同じ基準で扱う。誤報告と判断したものは理由を記録して除く
 
 集約結果の総数と内訳を 1 行で報告してから Step 5 に進む (`changed` / `pre-existing` の件数も併記する)。
 
@@ -153,7 +156,7 @@ shinaps-ai サーバは git / file / AI 推論を一切呼ばない。すべて
 
 ### 自明な修正 (auto-apply、`changed` のみ)
 
-修正方法が一意で設計判断を伴わない finding は、ユーザーに確認せず `Edit` / `Write` で即修正する:
+lint 由来の指摘は auto-apply にしない (ルールは構文で判定するので、意図した例外も報告しうる)。修正方法が一意で設計判断を伴わない finding は、ユーザーに確認せず `Edit` / `Write` で即修正する:
 
 - コメント / 文言 / typo の修正 (規約が指す直し方が一つしかない)
 - 既存パターンへの機械的な追従 (隣接コードと同じ流儀に揃えるだけ)
@@ -185,6 +188,7 @@ shinaps-ai サーバは git / file / AI 推論を一切呼ばない。すべて
 
 - 対象ファイル数と、その決め方 (`git diff HEAD` の変更ファイル / PR / commit range / path 指定のどれか) を冒頭に明示
 - [Shinaps規約の取得](../../references/rules.md) の「照合結果に書くこと」
+- 機械検査を使った場合は、状態ごとの組の数 (照合から外した `covered`・`violation` を含む)、`not-run` の理由。使えなかった場合はその理由
 - 実際の担当数・バッチ数と各担当の finding 件数、照合済みファイル数、非該当・未完了のファイルと理由
 - 検出 / 処理した finding の総数と内訳 (自動修正 X 件 / 確認の上修正 Y 件 / 許容 Z 件 / rule 更新 W 件 / 後回し V 件)
 - **`changed` と `pre-existing` の内訳** (既存箇所の指摘が何件あり、そのうち何件を今回直したか。今回の変更に無関係な修正がどれだけ混ざったかをユーザーが把握できるように)

package/plugins/shinaps-codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "shinaps",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Shinaps AIのCodex向け開発ワークフロー",
   "skills": "./skills/"
 }

package/plugins/shinaps-codex/references/linear/configuration.md

@@ -4,7 +4,7 @@
 
 ## 検証CLIと契約版
 
-利用中のskillとCLIの版を確認し、0.43.0のskillには同じ版のnpm CLIを導入する（`npm install -g @shinaps/skills@0.43.0`）。pluginだけにはCLIは含まれない。導入・更新が必要ならその権限を確認し、検証のたびに `npx latest` を取得しない。
+利用中のskillとCLIの版を確認し、0.44.0のskillには同じ版のnpm CLIを導入する（`npm install -g @shinaps/skills@0.44.0`）。pluginだけにはCLIは含まれない。導入・更新が必要ならその権限を確認し、検証のたびに `npx latest` を取得しない。
 
 0.35.0から通常設定の `review_flow.mode` に `ask` を受理する。`config_version` は2のままで、既存のauto・manualの設定は変更不要。0.33.0〜0.34.xのCLIと `$schema` のURLは `ask` を拒否するため、`ask` を使う設定では `$schema` も0.35.0以降のURLにする。
 

package/plugins/shinaps-codex/references/lint.md

@@ -0,0 +1,34 @@
+# 規約の機械検査（Shinaps lint）
+
+Shinaps AIの規約は、機械検査（`checks`）を持てる。検査は配布CLI `shinaps-skills lint` が、プロジェクトのlint設定・script・依存を使わずに手元で実行する。プロジェクトの変更は要らない。対象のコード・差分・結果はサーバーへ送らない。CLIの入出力と同梱ルールの追加手順は、配布パッケージの `docs/lint.md` にある。
+
+検査で照合を省いてよいのは、静的に保証できた組（規約×ファイル）だけ。未実行・対象外・エラー・一部だけの検査は合格にせず、AI照合に回す。
+
+## 照合で使う
+
+[Shinaps規約の取得](rules.md)で全文を取得した後、照合の担当へ渡す前に行う。
+
+1. 全文の `checks` を持つ規約を、`{ "rules": [{ "id": "<規約id>", "checks": [<全文のchecksのまま>] }] }` の形で作業記録の下（例: `.shinaps/work/<作業>/lint-checks.json`）に書く。checksを書き換えない。持つ規約が無ければこの節を省く。
+2. 対象ファイル（照合の対象として確定したもの。削除されたファイルを除く）を付けて1回実行する。
+
+   ```sh
+   shinaps-skills lint --checks <lint-checks.json> --root <リポジトリのルート> --out <lint-result.json> -- <対象ファイル...>
+   ```
+
+   コマンドが無い、終了コードが0でない、または結果を読めないときは、全ての規約をAI照合に回し、理由を報告する。CLIは利用中のスキルと同じ版を使う。
+3. 結果の `pairs` は規約×ファイルの組ごとに状態を持つ。
+   - `covered`: 全体を検査する検査（coverage `full`）が実行され、違反が無い。この組は担当の照合から外す。
+   - `violation`: 全体を検査する検査が実行され、指摘がある（同じ規約の一部だけを検査する検査の指摘を含む）。照合から外し、`findings` を指摘にする。
+   - `partial`: 一部だけを検査する検査だけが実行された。`findings` を指摘にし、規約はそのファイルの照合に残す（担当にはlintの指摘も渡す）。
+   - `not-run`: 実行していない（対象外、この版に無いルール、ESLintが設定を拒否した、型が得られない、致命的な報告など）。照合に残し、`reason` を記録する。
+4. lint由来の指摘は、根拠に規約idとルールID（`findings[].rule`）を付けて集約に入れる。誤報告がありうるので自動修正にせず、メインがその位置を読んで確認してから扱う。
+5. 報告に、状態ごとの組の数、`not-run` の理由、`units[].error` を書く。照合から外した組を「AIが照合した」と書かない。
+
+## 検査を登録・更新する
+
+[Shinaps規約の書き方](rule-writing.md)で書き込む規約に、検査を付けられるかを判断する。
+
+- **使えるルール**: ESLint core、`@typescript-eslint/*`（型情報を使うものを含む）、`vue/*`、同梱の `shinaps/*`（`docs/lint.md` の一覧）。版によって違うので、同じ版のCLIで確かめる。使えるルールが無い規約には検査を付けない（AI照合のまま）。同梱ルールの追加は `docs/lint.md` の手順で別の作業として提案する。
+- **coverageの判断**: 規約の全文（scope・labelsを含み、更新では更新後の全文）と、検査の `rule`・`options`・`files` を照らす。`files` の範囲で、規約が求めることへの違反をこのルールが全て報告すると言えるときだけ `full`、見逃しが一つでもありうれば `partial`。lintが規約より広く報告する（例外も報告する）ことは `full` の妨げにならない（指摘はメインが確認する）。例で通ることは根拠にならない。
+- **補助の確認**: 規約のgood・badの例を一時ディレクトリにファイルとして書き、同じ入口で実行して、badで報告され、goodで報告されないことを確かめる。対象プロジェクトのコードを写さない。
+- **書き込み**: `record_rule`・`update_rule` の `checks` に渡す。一括の `record_rules` は `checks` を受け取らない（付けると呼出し全体が入力エラーになる）ので、検査は登録後に `update_rule` で付ける。`update_rule` は配列ごと置換し、`[]` で外す。検査を持つ規約の内容（出典以外）を変える更新では、更新後の全文で検査を見直し、同じ要求で `checks` を渡す。渡さないと `CHECKS_REQUIRED` で保存されない。見直した結果が同じなら同じ配列を渡す。

package/plugins/shinaps-codex/references/rule-writing.md

@@ -34,6 +34,10 @@ Shinaps AIへ個人規約を登録・更新するときの書き方。短さそ
 
 結果は候補ごとに、比べた既存の規約のidまたは相手の候補、未確定ならその旨、取得の条件、未完了の範囲と返らない範囲を添えて報告する。
 
+## 機械検査
+
+coding の規約は、使えるlintのルールで検査できるかを判断し、できるものには `checks` を付ける。coverageの決め方・補助の確認・書き込みと、検査を持つ規約の内容を変えるときの見直しは[規約の機械検査](lint.md)の「検査を登録・更新する」に従う。
+
 ## 項目の役割
 
 各項目は役割が重ならないようにし、同じ内容を言い換えて繰り返さない。

package/plugins/shinaps-codex/references/rules.md

@@ -70,7 +70,7 @@ Shinaps AIのMCPから規約を取得する手順。取得は呼出し元（メ
 
 ## 担当へ渡す
 
-全文は取得した応答の単位で、続きのバッチとして渡す。1回の依頼に全件をまとめない。担当には読み終えた規約のidを報告させ、報告の無い範囲は同じ担当へ戻す。
+`checks` を持つ規約がある照合では、渡す前に[規約の機械検査](lint.md)の「照合で使う」を行い、照合から外す組を決める。全文は取得した応答の単位で、続きのバッチとして渡す。1回の依頼に全件をまとめない。担当には読み終えた規約のidを報告させ、報告の無い範囲は同じ担当へ戻す。
 
 ## 照合結果に書くこと
 

package/plugins/shinaps-codex/skills/refine/SKILL.md

@@ -7,6 +7,8 @@ description: 対象ファイルとShinaps AIのルールを照合し、違反・
 
 指定されたパス・PR・コミット範囲から対象を決める。作業中の変更ならstaged、unstaged、関連するuntrackedを含める。適用されるプロジェクトの指示を読み、[Shinaps規約の取得](../../references/rules.md)に従って、対象ファイルについて規約全文を取得する。MCPが使えない場合は照合を実施できないと報告し、推測でルールを作らない。アカウント作成・接続は利用者の標準認証フローを案内する。
 
+取得した規約に `checks` があれば、照合の前に[規約の機械検査](../../references/lint.md)の「照合で使う」に従い、静的に保証できた組（`covered`・`violation`）をその規約の照合から外し、lintの指摘は位置を読んで確かめてから扱う（自動修正しない）。照合から外した組と `not-run` の理由を報告する。
+
 対象ファイルの現状全文を読み、ルールごとに適用条件と実際のコードを比較する。指摘には根拠となるルール、該当箇所、影響と修正案を付ける。違反・改善・仕様判断を区別し、今回の変更と元からある問題を分ける。テストに関わる指摘と修正の判断は [テスト方針](../../references/testing.md) に従う。
 
 委託を許可されている場合は登録済みのshinaps-refine-agentへ重ならない範囲とルール全文を渡せる。担当の起動・継続は[担当の起動](../../references/dev/launch.md)に従う。結果は現在のコードで検証し重複をまとめる。独立検証をしなければそのように報告する。