akari-video 0.1.32 → 0.1.34

package/README.md

@@ -50,7 +50,9 @@ DL・sha256 検証・適用まで実行。それ以外（npm グローバル / g
 配布物の取得ができる。`src/store-command.mjs`）/
 `akari assets <list|fetch|sync|...>`（素材カタログの一覧・取得・同期。
 `packages/asset-resolver` の CLI への薄い委譲で、カタログ合成・entitlements 判定・
-sha256 検証・fail-closed は resolver 側の責務のまま。`src/assets-command.mjs`）。
+sha256 検証・fail-closed は resolver 側の責務のまま。`src/assets-command.mjs`）/
+`akari clean [project-dir] [--dry-run] [--yes] [--json]`（使い捨ての中間ファイル、保持する
+正本、判断が必要なものを容量付きで一覧する。既定は一覧のみで、削除可能なものだけを承認後に削除）。
 
 `akari` に渡した引数はそのまま `opencode` に転送する（例: `akari --continue` は
 `opencode --continue` を起動する）。

package/bin/akari.mjs

@@ -11,6 +11,7 @@ import { runCapabilityCommand } from '../src/capability-command.mjs';
 import { runStoreCommand } from '../src/store-command.mjs';
 import { runAssetsCommand } from '../src/assets-command.mjs';
 import { runMigrateCommand } from '../src/migrate-command.mjs';
+import { runCleanCommand } from '../src/clean-command.mjs';
 import { runDoctorCommand } from '../src/doctor-command.mjs';
 import { resolveRuntimePaths } from '../src/runtime-diagnostics.mjs';
 import { maybeApplyPendingUpdateOnLaunch, resolveInstalledVersionInfo } from '../src/update-check.mjs';
@@ -59,7 +60,7 @@ try {
 
 // `akari update` / `akari init` / `akari new` / `akari narration` / `akari internal` /
 // `akari sounds` / `akari status` / `akari accept` / `akari capability` / `akari store` /
-// `akari assets` は claude へ転送せず、専用のサブコマンドとして扱う（契約 §4-1 /
+// `akari assets` / `akari clean` は claude へ転送せず、専用のサブコマンドとして扱う（契約 §4-1 /
 // タスク契約 launcher-init（内部リポ）/ 音源カタログ既定化のオーナー裁定 2026-08-03 /
 // AKARI Store 連携 / タスク契約 2026-08-09-agent-assets-discovery）。
 // それ以外の引数はすべて従来どおり claude へ転送する。
@@ -78,6 +79,7 @@ const invoke = (argv[0] === '--version' || argv[0] === '-v') ? printVersion()
   : argv[0] === 'store' ? runStoreCommand(argv.slice(1))
   : argv[0] === 'assets' ? runAssetsCommand(argv.slice(1))
   : argv[0] === 'migrate' ? runMigrateCommand(argv.slice(1))
+  : argv[0] === 'clean' ? runCleanCommand(argv.slice(1))
   : run(argv);
 
 const result = await invoke.catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "AKARI Video launcher CLI — start an AI-edited video project from any directory: scaffold, connection check, then hand over to Claude Code (or opencode). AKARI Video を opencode や Claude Code で、どのディレクトリからでも始めるための `akari` ランチャー CLI。接続確認（doctor）→ 未セットアップならプロジェクト雛形を作成 → AI エージェントを起動する。外部 npm 依存ゼロ（Node.js 組み込みモジュールのみ）。",
   "type": "module",
   "bin": {

package/src/clean-command.mjs

@@ -0,0 +1,191 @@
+import { lstat, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+
+import { classifyProject } from './clean-manifest.mjs';
+
+export async function runCleanCommand(args, options = {}) {
+  const log = options.log ?? ((line) => console.log(line));
+  const error = options.error ?? ((line) => console.error(line));
+  const cwd = options.cwd ?? process.cwd();
+  const parsed = parseArguments(args, cwd);
+  if (!parsed.ok) {
+    error(parsed.message);
+    for (const line of cleanHelp()) error(line);
+    return { exitCode: 2 };
+  }
+  if (parsed.help) {
+    for (const line of cleanHelp()) log(line);
+    return { exitCode: 0 };
+  }
+
+  const statPath = options.lstat ?? lstat;
+  try {
+    const editStat = await statPath(path.join(parsed.projectRoot, 'edit.json'));
+    if (!editStat.isFile()) throw Object.assign(new Error('not a file'), { code: 'ENOENT' });
+  } catch {
+    error(`edit.json が見つかりません: ${parsed.projectRoot}`);
+    return { exitCode: 2 };
+  }
+
+  let classification;
+  try {
+    classification = await (options.classify ?? classifyProject)(parsed.projectRoot, {
+      now: options.now,
+      lstat: options.lstat,
+      readdir: options.readdir,
+      readFile: options.readFile,
+    });
+  } catch (cause) {
+    error(`プロジェクトを調べられません: ${messageOf(cause)}`);
+    return { exitCode: 2 };
+  }
+
+  if (parsed.json) {
+    log(JSON.stringify(classification));
+  } else {
+    for (const line of formatClassification(classification)) log(line);
+    for (const warning of provenanceWarnings(classification)) log(warning);
+  }
+
+  if (parsed.dryRun || classification.disposable.length === 0) {
+    if (!parsed.json && classification.disposable.length === 0) log('削除対象はありません。');
+    return { exitCode: 0, classification, removed: [], failures: [] };
+  }
+
+  if (!parsed.yes) {
+    const isTTY = options.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!isTTY) {
+      error('非 TTY では明示承認が必要です。一覧を確認し、--yes を付けて再実行してください。');
+      return { exitCode: 2, classification, removed: [], failures: [] };
+    }
+    const answer = options.prompt ? await options.prompt() : await promptForConfirmation();
+    const accepted = typeof answer === 'boolean' ? answer : /^(?:y|yes)$/iu.test(String(answer).trim());
+    if (!accepted) {
+      if (!parsed.json) log('削除しませんでした。プロジェクトは変更されていません。');
+      return { exitCode: 0, classification, removed: [], failures: [] };
+    }
+  }
+
+  const remove = options.remove ?? ((target) => rm(target, { recursive: true, force: true }));
+  const removed = [];
+  const failures = [];
+  for (const entry of classification.disposable) {
+    const target = path.resolve(parsed.projectRoot, entry.path);
+    if (!isInside(parsed.projectRoot, target) || target === parsed.projectRoot) {
+      const failure = { path: entry.path, code: 'OUTSIDE_PROJECT' };
+      failures.push(failure);
+      error(`削除に失敗しました: ${entry.path} (${failure.code})`);
+      continue;
+    }
+    try {
+      await remove(target, { recursive: true, force: true });
+      removed.push(entry.path);
+    } catch (cause) {
+      const code = errorCode(cause);
+      failures.push({ path: entry.path, code });
+      error(`削除に失敗しました: ${entry.path} (${code})`);
+    }
+  }
+
+  if (failures.length > 0) {
+    error('一部を削除できませんでした。AKARI Video と書き出し処理を終了してから再実行してください。');
+    return { exitCode: 1, classification, removed, failures };
+  }
+  if (!parsed.json) log(`削除しました: ${removed.length} 件`);
+  return { exitCode: 0, classification, removed, failures };
+}
+
+export function parseArguments(args, cwd = process.cwd()) {
+  const allowed = new Set(['--dry-run', '--yes', '--json', '--help']);
+  const flags = args.filter((value) => value.startsWith('-'));
+  const unknown = [...new Set(flags.filter((value) => !allowed.has(value)))];
+  if (unknown.length > 0) return { ok: false, message: `未知のオプションです: ${unknown.join(', ')}` };
+  const positional = args.filter((value) => !value.startsWith('-'));
+  if (positional.length > 1) return { ok: false, message: '引数のプロジェクトディレクトリは 1 つだけ指定できます。' };
+  const flagSet = new Set(flags);
+  return {
+    ok: true,
+    help: flagSet.has('--help'),
+    yes: flagSet.has('--yes'),
+    dryRun: flagSet.has('--dry-run'),
+    json: flagSet.has('--json'),
+    projectRoot: path.resolve(cwd, positional[0] ?? '.'),
+  };
+}
+
+export function cleanHelp() {
+  return [
+    '使い方: akari clean [dir] [--dry-run] [--yes] [--json] [--help]',
+    '',
+    '使い捨ての中間ファイル、保持する正本、判断が必要なものを一覧します。',
+    '既定では一覧だけを表示し、削除前には必ず確認します。',
+    '',
+    '  --dry-run  一覧だけを表示して削除しない',
+    '  --yes      一覧を表示した後、削除可能なものだけを削除',
+    '  --json     分類結果を JSON で表示',
+    '  --help     このヘルプを表示',
+  ];
+}
+
+export function formatClassification(classification) {
+  const lines = [];
+  for (const [className, heading] of [
+    ['disposable', '削除可能:'],
+    ['keep', '保持:'],
+    ['undecided', '判断保留:'],
+  ]) {
+    lines.push(heading);
+    const entries = classification[className];
+    if (entries.length === 0) lines.push('  （なし）');
+    for (const entry of entries) {
+      const provenance = entry.provenance
+        ? ` / 由来: ${entry.provenance.origin} / 生成器: ${entry.provenance.generator}`
+        : '';
+      lines.push(`  ${entry.path} | ${entry.files} ファイル | ${formatBytes(entry.bytes)} | ${entry.reason}${provenance}`);
+    }
+  }
+  lines.push(`削除可能 合計 ${formatBytes(classification.totals.disposable.bytes)}`);
+  return lines;
+}
+
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ['KB', 'MB', 'GB'];
+  let value = bytes / 1024;
+  let unit = units[0];
+  for (let index = 1; index < units.length && value >= 1024; index += 1) {
+    value /= 1024;
+    unit = units[index];
+  }
+  return `${value.toFixed(1)} ${unit}`;
+}
+
+function provenanceWarnings(classification) {
+  return classification.keep
+    .filter((entry) => entry.provenance?.origin_exists === false)
+    .map((entry) => `[警告] 由来の計画ファイルが見当たりません: ${entry.provenance.origin}`);
+}
+
+async function promptForConfirmation() {
+  const readline = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await readline.question('削除可能な中間ファイルだけを削除しますか? [y/N] ');
+  } finally {
+    readline.close();
+  }
+}
+
+function isInside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative !== '' && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative);
+}
+
+function errorCode(error) {
+  if (error && typeof error === 'object') return String(error.code ?? error.errno ?? messageOf(error));
+  return messageOf(error);
+}
+
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/clean-manifest.mjs

@@ -0,0 +1,435 @@
+import { lstat as fsLstat, readdir as fsReaddir, readFile as fsReadFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const RECENT_GUARD_MS = 60 * 60 * 1000;
+
+export const CLEAN_MANIFEST = Object.freeze([
+  manifest('.akari/render-tmp/*', 'disposable', '書き出しの一時作業領域', 'render-cut'),
+  manifest('.akari/cache/**', 'disposable', '原本から再生成できるキャッシュ', 'AKARI Video'),
+  manifest('.akari/diffs/*', 'disposable', '「変更を見る」で再生成できる差分', 'AKARI Video'),
+  manifest('exports/*.gpu-video.mp4', 'disposable', 'GPU 書き出しの映像中間ファイル', 'render-cut'),
+  manifest('exports/*.osr-video.mp4', 'disposable', 'OSR 書き出しの映像中間ファイル', 'render-cut'),
+  manifest('exports/run.json', 'disposable', '書き出し子プロセスの一時記録', 'render-cut'),
+  manifest('.akari/work/tmp/**', 'disposable', '明示された使い捨て作業領域', '実行したスキル'),
+  manifest('.akari/work/** (with .akari-disposable)', 'disposable', '使い捨て目印がある作業領域', '実行したスキル'),
+
+  manifest('edit.json', 'keep', '編集内容の正本', null),
+  manifest('captions.json', 'keep', '字幕データ', null),
+  manifest('review.json', 'keep', 'レビュー注釈', null),
+  manifest('plan.json', 'keep', '承認済みの計画', null),
+  manifest('motion/**', 'keep', '再生成できないキーフレーム曲線', null),
+  manifest('assets/**', 'keep', '素材の原本', null),
+  manifest('planning/**', 'keep', '企画・計画文書', null),
+  manifest('exports/*.mp4', 'keep', '納品用の書き出し', null),
+  manifest('exports/nle/**', 'keep', 'NLE 用の書き出し', null),
+  manifest('.akari/reports/**', 'keep', '検証と人間確認の証跡', null),
+  manifest('.akari/sidecars/**', 'keep', '素材分析などの高価なサイドカー', null),
+  manifest('.akari/*.json', 'keep', 'プロジェクト状態の契約ファイル', null),
+  manifest('.akari/backup/**', 'keep', '移行前の退避', null),
+  manifest('.akari/events/**', 'keep', '節目の記録', null),
+  manifest('.akari/work/keep/**', 'keep', '作り直せない作業成果', null),
+  manifest('.akari/work/** (with .akari-keep)', 'keep', '保持目印がある作業領域', null),
+  manifest('.akari/work/**/.akari-disposable', 'keep', '作業領域の分類目印', null),
+  manifest('.akari/work/**/.akari-keep', 'keep', '作業領域の分類目印', null),
+  manifest('.claude/**', 'keep', 'プロジェクトのエージェント設定', null),
+  manifest('.opencode/**', 'keep', 'プロジェクトのエージェント設定', null),
+  manifest('AGENTS.md', 'keep', 'プロジェクトのエージェント向け案内', null),
+  manifest('CLAUDE.md', 'keep', 'プロジェクトのエージェント向け案内', null),
+  manifest('akari.sh', 'keep', 'プロジェクトの起動スクリプト', null),
+  manifest('.gitignore', 'keep', 'プロジェクトの除外設定', null),
+
+  manifest('.akari/work/**', 'undecided', '使い捨てと正本の区別がない作業領域', null),
+  manifest('<recent-disposable>', 'undecided', '実行中の可能性', null),
+  manifest('<symbolic-link>', 'undecided', 'シンボリックリンク（参照先は調べません）', null),
+  manifest('<unknown-top-level>', 'undecided', '宣言表に分類がありません', null),
+]);
+
+const RULES = new Map(CLEAN_MANIFEST.map((entry) => [entry.pattern, entry]));
+
+function manifest(pattern, className, reason, regeneratedBy) {
+  return Object.freeze({ pattern, class: className, reason, regenerated_by: regeneratedBy });
+}
+
+function rule(pattern) {
+  const entry = RULES.get(pattern);
+  if (!entry) throw new Error(`clean manifest rule is missing: ${pattern}`);
+  return entry;
+}
+
+/**
+ * Project contents are grouped at boundaries that can be removed independently. The returned
+ * paths never contain absolute machine paths and every list is sorted with a platform-neutral
+ * code-point comparison.
+ */
+export async function classifyProject(root, options = {}) {
+  const projectRoot = path.resolve(root);
+  const io = {
+    lstat: options.lstat ?? fsLstat,
+    readdir: options.readdir ?? fsReaddir,
+    readFile: options.readFile ?? fsReadFile,
+  };
+  const nowValue = typeof options.now === 'function' ? options.now() : (options.now ?? Date.now());
+  const nowMs = nowValue instanceof Date ? nowValue.getTime() : Number(nowValue);
+  if (!Number.isFinite(nowMs)) throw new TypeError('now must be a Date or a finite timestamp');
+
+  const rootNode = await scanNode(projectRoot, '', io);
+  if (rootNode.kind !== 'directory') throw new Error(`project root is not a directory: ${projectRoot}`);
+
+  const buckets = { disposable: [], keep: [], undecided: [] };
+  const context = { projectRoot, io, nowMs, buckets };
+  for (const child of rootNode.children) await classifyTopLevel(child, context);
+
+  for (const className of ['disposable', 'keep', 'undecided']) {
+    buckets[className].sort((left, right) => comparePath(left.path, right.path));
+  }
+
+  return {
+    disposable: buckets.disposable,
+    keep: buckets.keep,
+    undecided: buckets.undecided,
+    totals: {
+      disposable: totalOf(buckets.disposable),
+      keep: totalOf(buckets.keep),
+      undecided: totalOf(buckets.undecided),
+    },
+  };
+}
+
+async function classifyTopLevel(node, context) {
+  if (node.kind === 'symlink') return addSymlink(node, context);
+
+  const exactKeep = new Map([
+    ['edit.json', 'edit.json'],
+    ['captions.json', 'captions.json'],
+    ['review.json', 'review.json'],
+    ['plan.json', 'plan.json'],
+    ['AGENTS.md', 'AGENTS.md'],
+    ['CLAUDE.md', 'CLAUDE.md'],
+    ['akari.sh', 'akari.sh'],
+    ['.gitignore', '.gitignore'],
+  ]);
+  if (exactKeep.has(node.rel)) return addKnownKeep(node, rule(exactKeep.get(node.rel)), context);
+
+  if (node.rel === 'motion' && node.kind === 'directory') return addKnownKeep(node, rule('motion/**'), context);
+  if (node.rel === 'planning' && node.kind === 'directory') return addKnownKeep(node, rule('planning/**'), context);
+  if (node.rel === '.claude' && node.kind === 'directory') return addKnownKeep(node, rule('.claude/**'), context);
+  if (node.rel === '.opencode' && node.kind === 'directory') return addKnownKeep(node, rule('.opencode/**'), context);
+  if (node.rel === 'assets' && node.kind === 'directory') return classifyAssets(node, context);
+  if (node.rel === 'exports' && node.kind === 'directory') return classifyExports(node, context);
+  if (node.rel === '.akari' && node.kind === 'directory') return classifyAkari(node, context);
+
+  addEntry(node, rule('<unknown-top-level>'), context);
+}
+
+async function classifyAssets(assets, context) {
+  if (assets.children.length === 0) return addEntry(assets, rule('assets/**'), context);
+  for (const child of assets.children) {
+    if (child.kind === 'symlink') addSymlink(child, context);
+    else if (child.name === 'generated' && child.kind === 'directory') await classifyGeneratedAssets(child, context);
+    else addKnownKeep(child, rule('assets/**'), context);
+  }
+}
+
+async function classifyGeneratedAssets(directory, context) {
+  if (directory.children.length === 0) {
+    addEntry(directory, rule('assets/**'), context);
+    return;
+  }
+
+  const consumed = new Set();
+  const childrenByName = new Map(directory.children.map((child) => [child.name, child]));
+  for (const child of directory.children) {
+    if (consumed.has(child.name)) continue;
+    if (child.kind === 'symlink') {
+      addSymlink(child, context);
+      continue;
+    }
+    if (child.kind === 'directory') {
+      await classifyGeneratedAssets(child, context);
+      continue;
+    }
+    if (child.name.endsWith('.meta.json')) {
+      addEntry(child, rule('assets/**'), context);
+      continue;
+    }
+
+    const sidecar = childrenByName.get(`${child.name}.meta.json`);
+    let provenance;
+    let stats = statsOf(child);
+    if (sidecar?.kind === 'file') {
+      consumed.add(sidecar.name);
+      stats = combineStats(child, sidecar);
+      provenance = await readProvenance(sidecar.abs, context);
+    }
+    addEntry(child, rule('assets/**'), context, { stats, provenance });
+  }
+}
+
+function classifyExports(exportsNode, context) {
+  for (const child of exportsNode.children) {
+    if (child.kind === 'symlink') {
+      addSymlink(child, context);
+    } else if (child.name === 'nle' && child.kind === 'directory') {
+      addKnownKeep(child, rule('exports/nle/**'), context);
+    } else if (child.kind === 'file' && child.name.endsWith('.gpu-video.mp4')) {
+      addDisposable(child, rule('exports/*.gpu-video.mp4'), context);
+    } else if (child.kind === 'file' && child.name.endsWith('.osr-video.mp4')) {
+      addDisposable(child, rule('exports/*.osr-video.mp4'), context);
+    } else if (child.kind === 'file' && child.name === 'run.json') {
+      addDisposable(child, rule('exports/run.json'), context);
+    } else if (child.kind === 'file' && child.name.endsWith('.mp4')) {
+      addEntry(child, rule('exports/*.mp4'), context);
+    } else {
+      addEntry(child, rule('<unknown-top-level>'), context);
+    }
+  }
+}
+
+async function classifyAkari(akari, context) {
+  const keepDirectories = new Map([
+    ['reports', '.akari/reports/**'],
+    ['sidecars', '.akari/sidecars/**'],
+    ['backup', '.akari/backup/**'],
+    ['events', '.akari/events/**'],
+  ]);
+
+  for (const child of akari.children) {
+    if (child.kind === 'symlink') {
+      addSymlink(child, context);
+    } else if (child.name === 'render-tmp' && child.kind === 'directory') {
+      for (const candidate of child.children) addDisposable(candidate, rule('.akari/render-tmp/*'), context);
+    } else if (child.name === 'cache' && child.kind === 'directory') {
+      for (const candidate of child.children) addDisposable(candidate, rule('.akari/cache/**'), context);
+    } else if (child.name === 'diffs' && child.kind === 'directory') {
+      for (const candidate of child.children) addDisposable(candidate, rule('.akari/diffs/*'), context);
+    } else if (child.name === 'work' && child.kind === 'directory') {
+      await classifyWork(child, context);
+    } else if (keepDirectories.has(child.name) && child.kind === 'directory') {
+      addKnownKeep(child, rule(keepDirectories.get(child.name)), context);
+    } else if (child.kind === 'file' && child.name.endsWith('.json')) {
+      addEntry(child, rule('.akari/*.json'), context);
+    } else {
+      addEntry(child, rule('<unknown-top-level>'), context);
+    }
+  }
+}
+
+async function classifyWork(work, context) {
+  for (const child of work.children) {
+    if (child.kind === 'symlink') {
+      addSymlink(child, context);
+    } else if (child.name === 'tmp' && child.kind === 'directory') {
+      await classifyWorkNode(child, 'disposable', rule('.akari/work/tmp/**'), context);
+    } else if (child.name === 'keep' && child.kind === 'directory') {
+      addKnownKeep(child, rule('.akari/work/keep/**'), context);
+    } else {
+      await classifyWorkNode(child, 'undecided', rule('.akari/work/**'), context);
+    }
+  }
+}
+
+async function classifyWorkNode(node, inheritedClass, inheritedRule, context) {
+  if (node.kind === 'symlink') return addSymlink(node, context);
+  if (node.kind !== 'directory') {
+    if (isMarker(node.name)) return addEntry(node, markerRule(node.name), context);
+    if (inheritedClass === 'disposable') return addDisposable(node, inheritedRule, context);
+    return addEntry(node, inheritedRule, context);
+  }
+
+  const ownKeep = node.directKeepMarker;
+  const ownDisposable = node.directDisposableMarker;
+  if (inheritedClass === 'keep' || ownKeep) {
+    addKnownKeep(node, ownKeep ? rule('.akari/work/** (with .akari-keep)') : inheritedRule, context);
+    return;
+  }
+
+  const effectiveClass = ownDisposable ? 'disposable' : inheritedClass;
+  const effectiveRule = ownDisposable ? rule('.akari/work/** (with .akari-disposable)') : inheritedRule;
+  const hasNestedKeep = node.children.some((child) => child.kind === 'directory' && child.subtreeKeepMarker);
+  const mustSplit = hasNestedKeep || node.hasSymlink;
+
+  if (effectiveClass === 'disposable' && !mustSplit) {
+    addDisposable(node, effectiveRule, context);
+    return;
+  }
+  const hasNestedClassification = node.children.some((child) => (
+    child.kind === 'directory' && (child.subtreeKeepMarker || child.subtreeDisposableMarker)
+  ));
+  if (effectiveClass === 'undecided' && !hasNestedClassification && !node.hasSymlink) {
+    addEntry(node, effectiveRule, context);
+    return;
+  }
+  if (node.children.length === 0) {
+    addEntry(node, effectiveRule, context);
+    return;
+  }
+
+  for (const child of node.children) {
+    if (isMarker(child.name) && child.kind === 'file') {
+      addEntry(child, markerRule(child.name), context);
+    } else {
+      await classifyWorkNode(child, effectiveClass, effectiveRule, context);
+    }
+  }
+}
+
+function addKnownKeep(node, keepRule, context) {
+  if (node.kind === 'symlink') return addSymlink(node, context);
+  if (node.kind !== 'directory' || !node.hasSymlink) {
+    addEntry(node, keepRule, context);
+    return;
+  }
+  if (node.children.length === 0) addEntry(node, keepRule, context);
+  for (const child of node.children) addKnownKeep(child, keepRule, context);
+}
+
+function addDisposable(node, disposableRule, context) {
+  if (node.kind === 'symlink') return addSymlink(node, context);
+  if (node.hasSymlink) {
+    addEntry(node, rule('<symbolic-link>'), context, { heldReason: 'シンボリックリンクを含むため' });
+    return;
+  }
+  addEntry(node, disposableRule, context, { guardRecent: true });
+}
+
+function addSymlink(node, context) {
+  addEntry(node, rule('<symbolic-link>'), context);
+}
+
+function addEntry(node, manifestRule, context, options = {}) {
+  const stats = options.stats ?? statsOf(node);
+  let className = manifestRule.class;
+  let reason = manifestRule.reason;
+  let heldReason = options.heldReason;
+  if (options.guardRecent && stats.latestMtimeMs >= context.nowMs - RECENT_GUARD_MS) {
+    className = 'undecided';
+    heldReason = '実行中の可能性';
+    reason = rule('<recent-disposable>').reason;
+  }
+
+  const entry = {
+    path: portablePath(node.rel),
+    class: className,
+    reason,
+    files: stats.files,
+    bytes: stats.bytes,
+  };
+  if (heldReason) entry.held_reason = heldReason;
+  if (options.provenance) entry.provenance = options.provenance;
+  context.buckets[className].push(entry);
+}
+
+async function readProvenance(sidecarPath, context) {
+  try {
+    const value = JSON.parse(await context.io.readFile(sidecarPath, 'utf8'));
+    const provenance = value?.provenance;
+    if (!provenance || typeof provenance.origin !== 'string' || typeof provenance.generator !== 'string') return undefined;
+    const origin = portablePath(provenance.origin);
+    const originPath = path.resolve(context.projectRoot, provenance.origin);
+    let originExists = false;
+    if (isInside(context.projectRoot, originPath)) {
+      try {
+        const stat = await context.io.lstat(originPath);
+        originExists = stat.isFile();
+      } catch {
+        originExists = false;
+      }
+    }
+    return {
+      origin,
+      generator: provenance.generator,
+      ...(Array.isArray(provenance.inputs) ? { inputs: provenance.inputs.map(portablePath) } : {}),
+      ...(typeof provenance.created_at === 'string' ? { created_at: provenance.created_at } : {}),
+      origin_exists: originExists,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+async function scanNode(absolutePath, relativePath, io) {
+  const stat = await io.lstat(absolutePath);
+  const base = {
+    name: relativePath ? path.basename(absolutePath) : '',
+    abs: absolutePath,
+    rel: portablePath(relativePath),
+    files: 0,
+    bytes: 0,
+    latestMtimeMs: stat.mtimeMs,
+    hasSymlink: false,
+    directKeepMarker: false,
+    directDisposableMarker: false,
+    subtreeKeepMarker: false,
+    subtreeDisposableMarker: false,
+  };
+  if (stat.isSymbolicLink()) {
+    return { ...base, kind: 'symlink', files: 1, bytes: stat.size, hasSymlink: true, children: [] };
+  }
+  if (!stat.isDirectory()) {
+    return { ...base, kind: 'file', files: 1, bytes: stat.size, children: [] };
+  }
+
+  const names = await io.readdir(absolutePath);
+  names.sort(comparePath);
+  const children = [];
+  for (const name of names) {
+    children.push(await scanNode(path.join(absolutePath, name), relativePath ? path.join(relativePath, name) : name, io));
+  }
+  const directKeepMarker = children.some((child) => child.name === '.akari-keep' && child.kind === 'file');
+  const directDisposableMarker = children.some((child) => child.name === '.akari-disposable' && child.kind === 'file');
+  return {
+    ...base,
+    kind: 'directory',
+    children,
+    files: children.reduce((sum, child) => sum + child.files, 0),
+    bytes: children.reduce((sum, child) => sum + child.bytes, 0),
+    latestMtimeMs: Math.max(stat.mtimeMs, ...children.map((child) => child.latestMtimeMs)),
+    hasSymlink: children.some((child) => child.hasSymlink),
+    directKeepMarker,
+    directDisposableMarker,
+    subtreeKeepMarker: directKeepMarker || children.some((child) => child.subtreeKeepMarker),
+    subtreeDisposableMarker: directDisposableMarker || children.some((child) => child.subtreeDisposableMarker),
+  };
+}
+
+function statsOf(node) {
+  return { files: node.files, bytes: node.bytes, latestMtimeMs: node.latestMtimeMs };
+}
+
+function combineStats(...nodes) {
+  return {
+    files: nodes.reduce((sum, node) => sum + node.files, 0),
+    bytes: nodes.reduce((sum, node) => sum + node.bytes, 0),
+    latestMtimeMs: Math.max(...nodes.map((node) => node.latestMtimeMs)),
+  };
+}
+
+function totalOf(entries) {
+  return {
+    files: entries.reduce((sum, entry) => sum + entry.files, 0),
+    bytes: entries.reduce((sum, entry) => sum + entry.bytes, 0),
+  };
+}
+
+function markerRule(name) {
+  return rule(name === '.akari-keep'
+    ? '.akari/work/**/.akari-keep'
+    : '.akari/work/**/.akari-disposable');
+}
+
+function isMarker(name) {
+  return name === '.akari-keep' || name === '.akari-disposable';
+}
+
+function portablePath(value) {
+  return String(value).split(path.sep).join('/');
+}
+
+function comparePath(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function isInside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}

package/src/messages.mjs

@@ -330,6 +330,7 @@ export function describeCliHelp() {
     '  update [--force]       更新を確認する（--force で install.sh 経路の本体を入れ直す）',
     '  status                 接続状態を確認する',
     '  migrate [dir]          古い edit.json を退避バックアップ付きで v2 へ変換',
+    '  akari clean [dir]      使い捨ての中間ファイルを一覧・削除（既定は一覧のみ）',
     '',
     '開発者向け:',
     '  --opencode              Claude Code の代わりに opencode を起動する',