akari-video 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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/cli.mjs

@@ -6,7 +6,7 @@ import { resolveLauncherAssets } from './repo-assets.mjs';
 import { detectProjectState } from './project-state.mjs';
 import { findClaudeExecutable, findOpencodeExecutable } from './path-lookup.mjs';
 import { loadTaskLabels } from './task-labels.mjs';
-import { describeForceReinstall, describeInstalledVersions, describeIntake, claudeMissingGuidance, opencodeMissingGuidance, describeUpdateCommand, describeVersionStatus, formatUpdateNotice } from './messages.mjs';
+import { describeForceReinstall, describeInstalledVersions, describeIntake, claudeMissingGuidance, opencodeMissingGuidance, describeUpdateCacheFallback, describeUpdateCommand, describeVersionStatus, formatUpdateNotice } from './messages.mjs';
 import { resolveEffectiveProjectRoot } from './first-run.mjs';
 import { maybeShowAssetIntroNotice } from './sounds-setup.mjs';
 import {
@@ -188,8 +188,8 @@ function defaultSpawnOpencode(opencodePath, args, projectRoot) {
  * 自己更新を試みず、キャッシュに載っている最新版の通知を今後出さないよう記録するだけ
  * （既存挙動を維持）。`--force` は同じ版の本体も再導入し、`--rollback` は直前 1 世代
  * （`~/.akari/app-previous/`）へ戻す。
- * 通常時にネットワークへ触れるのは自己更新の DL 区間のみ。`--force` だけはキャッシュが
- * 未取得なら、復旧経路を塞がないためフィードの同期取得を 1 回試す。
+ * `--dismiss` / `--rollback` 以外の明示 update は、キャッシュ TTL に関係なく
+ * フィードの同期取得を 1 回試す。取得失敗時だけ既存キャッシュへフォールバックする。
  */
 export async function runUpdateCommand(args, options = {}) {
   const log = options.log ?? ((line) => console.log(line));
@@ -201,6 +201,7 @@ export async function runUpdateCommand(args, options = {}) {
   const dismissRequested = args.includes('--dismiss');
   const rollbackRequested = args.includes('--rollback');
   const forceRequested = args.includes('--force');
+  let usingCachedFeed = false;
 
   if (rollbackRequested) {
     return (options.rollbackSelfUpdate ?? rollbackSelfUpdate)({ env, log });
@@ -219,9 +220,12 @@ export async function runUpdateCommand(args, options = {}) {
     return { exitCode: 0 };
   }
 
-  if (forceRequested && !cache?.feed) {
-    await (options.refreshUpdateFeed ?? refreshUpdateFeed)({ env, fetchImpl: options.fetchImpl });
-    cache = readCacheSync(cachePath);
+  const refreshed = await (options.refreshUpdateFeed ?? refreshUpdateFeed)({ env, fetchImpl: options.fetchImpl });
+  if (isValidFeedShape(refreshed?.feed)) {
+    cache = refreshed;
+  } else {
+    cache = readCacheSync(cachePath) ?? cache;
+    usingCachedFeed = isValidFeedShape(cache?.feed);
   }
 
   const feed = cache?.feed;
@@ -234,12 +238,15 @@ export async function runUpdateCommand(args, options = {}) {
     && (hasManagedApp || (options.isRunningFromAppDir ?? isRunningFromAppDir)({ env, launcherRoot: options.launcherRoot }));
 
   if (!selfUpdateEligible) {
-    for (const line of describeUpdateCommand({ currentVersion, versionInfo, cache, dismissed: false })) {
+    for (const line of describeUpdateCommand({ currentVersion, versionInfo, cache, dismissed: false, usingCachedFeed })) {
       log(line);
     }
     return { exitCode: 0 };
   }
 
+  if (usingCachedFeed) {
+    log(describeUpdateCacheFallback(cache));
+  }
   for (const line of describeInstalledVersions(versionInfo)) {
     log(line);
   }

package/src/messages.mjs

@@ -172,7 +172,7 @@ export function creatorRootPromptText(defaultPath) {
  * `akari update` の出力本文（複数行）。フィード未取得・最新・新版ありで案内が変わる。
  * `dismissed` は今回の実行で dismiss 記録を書いたかどうか（表示文言の切り替えのみに使う）。
  */
-export function describeUpdateCommand({ currentVersion, versionInfo, cache, dismissed }) {
+export function describeUpdateCommand({ currentVersion, versionInfo, cache, dismissed, usingCachedFeed = false }) {
   const info = versionInfo ?? normalizeVersionInfo(currentVersion);
   const lines = versionInfo ? describeInstalledVersions(info) : [`現在のバージョン: v${currentVersion}`];
   const feed = cache?.feed;
@@ -182,6 +182,10 @@ export function describeUpdateCommand({ currentVersion, versionInfo, cache, dism
     return lines;
   }
 
+  if (usingCachedFeed) {
+    lines.push(describeUpdateCacheFallback(cache));
+  }
+
   lines.push(`最新バージョン: v${feed.product}${channelSuffix(feed.channel)}`);
   if (feed.notes_url) {
     lines.push(`リリースノート: ${feed.notes_url}`);
@@ -208,6 +212,12 @@ export function describeUpdateCommand({ currentVersion, versionInfo, cache, dism
   return lines;
 }
 
+/** 明示 update の再取得失敗時に、参照するキャッシュの取得時刻を示す 1 行。 */
+export function describeUpdateCacheFallback(cache) {
+  const fetchedAt = typeof cache?.fetched_at === 'string' ? cache.fetched_at : '取得時刻不明';
+  return `更新フィードを取得できなかったため、${fetchedAt} 時点のキャッシュを表示します。`;
+}
+
 /**
  * `akari init` の出力文言（タスク契約 launcher-init・内部リポ）。作業場
  * （creator-root）の作成・確認だけを行う入口コマンド専用。1 行主義の既存流儀に従う。

package/vendor/docs/contract-2026-07-22-render-basics.md

@@ -113,6 +113,23 @@ perspective のレイヤー分割フォールバック — perspective は `crop
   外形を四隅の基準にし、rotate と非 normal blend は固定外形化による既存意味の変化を排除できない
   ため、この組み合わせだけは従来互換経路を維持する。
 
+- **主映像カット拡大・crop の固定キャンバス化（2026-08-25 追記）**: v2 主映像トラックから
+  gap-aware cuts へ変換された `transform.scale` / crop キーフレームにも、レイヤー経路と同じ
+  `layerFixedCanvasKeyframeSteps` を適用する。normal blend・perspective 非宣言・rotate=0（静的・
+  キーフレームとも）の場合に限り、素材ネイティブ寸法の 2 倍グリッドで補間し、最大 footprint の
+  固定透明キャンバスへ偶数座標で配置した後、Lanczos で実寸へ縮小する。これにより毎フレームの
+  可変 bitmap 寸法と中央 overlay の組み合わせを排除し、拡大後サイズの偶奇変化による ±1px 往復を
+  防ぐ。perspective・rotate・非 normal blend は従来互換経路を維持し、キーフレーム無しカットの
+  filter 文字列は変更しない。
+
+- **rotate 適用条件の追補（2026-08-25）**: 上記の「rotate=0（静的・キーフレームとも）」は、
+  下流 filter に rotate ステップが実際に出るかどうかへ読み替え、`rotateConstant === 0` のときだけ
+  固定キャンバスを適用する。静的 `transform.rotate` が非 0 でも、キーフレームが `transform` を
+  宣言すれば rotate はキーフレーム由来の既定 0 で解決され、rotate ステップが出ないため対象となる
+  （rotate の描画意味論は不変）。これで `layers.mjs` の同名ガードと一致する。静的 rotate 非 0 かつ
+  transform キーフレーム無し、キーフレーム rotate が非 0、rotate が時間変化する構成は、rotate
+  ステップが実際に出るため従来互換経路を維持する。
+
 ## 5. macOS の字幕レンダ用 Chrome 起動（2026-08-24 追記）
 
 - macOS では `.app` 内の Chrome 実行ファイルを子プロセスとして直接起動しない。書き出し専用の

package/vendor/packages/akari-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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 組み込みモジュールのみ）。 [akari-video npm vendor: bin/akari.mjs is reference-only. These CLI entrypoints are not included in the akari-video npm package. Run them from a full AKARI Video app installation (normally ~/.akari/app) or a monorepo checkout.]",
   "type": "module",
   "files": [

package/vendor/packages/edit-lint/src/edit-lint.mjs

@@ -20,6 +20,8 @@ import { resolveFfmpeg, resolveFfprobe } from "../../media-bin/src/index.mjs";
 
 const {
   areCutsAdjacent,
+  cutOverlapFrames,
+  findCrossTrackLayerEvacuations,
   findUnsupportedDeclaredTrackTransitions,
   projectLegacyEdit,
   readInternalEdit,
@@ -135,6 +137,7 @@ export async function lintProject(input, options = {}) {
   const rawEdit = edit;
   const internalEdit = readInternalEdit(rawEdit);
   const legacyEdit = projectLegacyEdit(internalEdit);
+  validateTransitionLayerEvacuations(rawEdit, internalEdit, findings);
   const rawAudio = isRecord(rawEdit.audio) ? rawEdit.audio : {};
   const projectedAudio = projectAudioForLint(internalEdit);
   edit = {
@@ -325,8 +328,24 @@ function validateTransitionAdjacency(cuts, segments, fps, findings) {
     const transition = cuts?.[earlier.index]?.transition_out;
     if (!isRecord(transition) || !isPositiveNumber(transition.duration)) continue;
     const later = segments.slice(position + 1).find(candidate => candidate.track === earlier.track);
-    if (!later || later.start <= earlier.end) continue;
-    if (areCutsAdjacent(
+    if (!later) continue;
+    const overlapFrames = cutOverlapFrames(
+      { tlEnd: earlier.end },
+      { tlStart: later.start },
+      fps,
+    );
+    if (overlapFrames === 0) {
+      addFinding(findings, {
+        severity: "warning",
+        check: "cuts.transition-out.zero-overlap",
+        message: "トランジションを宣言していますが、次のクリップと重なっていないため効きません。前のクリップの終わりを延ばして重なりを作るか、トランジションを削除してください。",
+        path: `edit.json#cuts[${earlier.index}].transition_out`,
+        range: { start: earlier.end, end: later.start },
+      });
+      continue;
+    }
+    // 正の重なりは、宣言尺未満なら既存の短縮クランプ、宣言尺超なら track-overlap が担当する。
+    if (overlapFrames > 0 || areCutsAdjacent(
       { tlEnd: earlier.end, transitionOut: { duration: transition.duration } },
       { tlStart: later.start },
       fps,
@@ -341,6 +360,50 @@ function validateTransitionAdjacency(cuts, segments, fps, findings) {
   }
 }
 
+function validateTransitionLayerEvacuations(rawEdit, internalEdit, findings) {
+  if (!isRecord(rawEdit) || rawEdit.version !== 2) return;
+  const crossTrackCauses = new Map();
+  for (const cause of findCrossTrackLayerEvacuations(rawEdit)) {
+    if (!crossTrackCauses.has(cause.itemId)) crossTrackCauses.set(cause.itemId, cause);
+  }
+  const rawLocations = new Map();
+  if (Array.isArray(rawEdit.tracks)) {
+    rawEdit.tracks.forEach((track, trackIndex) => {
+      if (!isRecord(track) || !Array.isArray(track.items)) return;
+      track.items.forEach((item, itemIndex) => {
+        if (isRecord(item) && typeof item.id === "string") {
+          rawLocations.set(item.id, { trackIndex, itemIndex });
+        }
+      });
+    });
+  }
+  for (const track of internalEdit.tracks) {
+    for (const item of track.items) {
+      const transition = item.declaration?.transition_out;
+      if (item.legacy.collection !== "layers" || !isRecord(transition)) continue;
+      const location = rawLocations.get(item.id);
+      const cause = crossTrackCauses.get(item.id);
+      const reason = cause
+        ? `このクリップは他トラックのアイテム（${cause.causeItemId}）と重なっているため PiP 経路へ退避され、宣言したトランジションは書き出されません。`
+        : "このクリップは合成機能または同一トラック内の重なりにより PiP 経路へ退避され、宣言したトランジションは書き出されません。";
+      addFinding(findings, {
+        severity: "warning",
+        check: "cuts.transition-out.layer-evacuated",
+        message: `${reason}重なりを解消するか、トランジションを削除してください。`,
+        path: location
+          ? `edit.json#tracks[${location.trackIndex}].items[${location.itemIndex}].source.transition_out`
+          : `edit.json#tracks[${track.z}].items`,
+        ...(cause ? {
+          range: {
+            start: cause.overlapStartFrames / internalEdit.output.fps,
+            end: cause.overlapEndFrames / internalEdit.output.fps,
+          },
+        } : {}),
+      });
+    }
+  }
+}
+
 function projectAudioForLint(internalEdit) {
   const sfx = [];
   const narration = [];

package/vendor/packages/edit-store/lib/cut-adjacency.d.ts

@@ -12,6 +12,31 @@ export interface CutAdjacencyEarlierLike {
 export interface CutAdjacencyLaterLike {
     tlStart: number;
 }
+export declare function effectiveCutFps(fps: number): number;
+/**
+ * earlier の終端と later の開始を出力 fps へ量子化し、実重なりをフレーム数で返す。
+ * 正数は重なり、0 は突き合わせ、負数はすき間を表す。
+ */
+export declare function cutOverlapFrames(earlier: Pick<CutAdjacencyEarlierLike, 'tlEnd'>, later: CutAdjacencyLaterLike, fps?: number): number;
+export type TransitionHandleExtensionOutcome = 'already-overlapping' | 'full' | 'partial' | 'none';
+export interface TransitionHandleExtensionPlan {
+    appliedSeconds: number;
+    effectiveSeconds: number;
+    appliedFrames: number;
+    outcome: TransitionHandleExtensionOutcome;
+}
+export interface TransitionHandleExtensionInput {
+    declaredSeconds: number;
+    earlierEndSeconds: number;
+    laterStartSeconds: number;
+    maxExtendSeconds: number;
+    fps?: number;
+}
+/**
+ * 突き合わせ境界へ宣言尺ぶんの重なりを作るため、outgoing を何フレーム延ばすか決める。
+ * メディア長は知らず、呼び出し側が maxExtendSeconds として渡した上限だけを使う。
+ */
+export declare function planTransitionHandleExtension(input: TransitionHandleExtensionInput): TransitionHandleExtensionPlan;
 /**
  * ギャップ 0、または earlier の宣言済み transitionOut.duration で説明できる重なりだけを
  * 隣接とみなす。秒の誤差ではなく、出力 fps で量子化したフレーム数を比較する。

package/vendor/packages/edit-store/lib/cut-adjacency.js

@@ -4,20 +4,63 @@
  * タイムライン UI と edit-lint は必ずこの関数を使い、フレーム量子化の条件式を複製しない。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveCutFps = effectiveCutFps;
+exports.cutOverlapFrames = cutOverlapFrames;
+exports.planTransitionHandleExtension = planTransitionHandleExtension;
 exports.areCutsAdjacent = areCutsAdjacent;
 const DEFAULT_CUT_ADJACENCY_FPS = 30;
-function effectiveFps(fps) {
+function effectiveCutFps(fps) {
     return Number.isFinite(fps) && fps > 0 ? fps : DEFAULT_CUT_ADJACENCY_FPS;
 }
+/**
+ * earlier の終端と later の開始を出力 fps へ量子化し、実重なりをフレーム数で返す。
+ * 正数は重なり、0 は突き合わせ、負数はすき間を表す。
+ */
+function cutOverlapFrames(earlier, later, fps = DEFAULT_CUT_ADJACENCY_FPS) {
+    const resolvedFps = effectiveCutFps(fps);
+    return Math.round(earlier.tlEnd * resolvedFps) - Math.round(later.tlStart * resolvedFps);
+}
+/**
+ * 突き合わせ境界へ宣言尺ぶんの重なりを作るため、outgoing を何フレーム延ばすか決める。
+ * メディア長は知らず、呼び出し側が maxExtendSeconds として渡した上限だけを使う。
+ */
+function planTransitionHandleExtension(input) {
+    const fps = effectiveCutFps(input.fps ?? DEFAULT_CUT_ADJACENCY_FPS);
+    const declaredFrames = Number.isFinite(input.declaredSeconds) && input.declaredSeconds > 0
+        ? Math.max(1, Math.round(input.declaredSeconds * fps)) : 0;
+    const overlapFrames = cutOverlapFrames({ tlEnd: input.earlierEndSeconds }, { tlStart: input.laterStartSeconds }, fps);
+    if (overlapFrames > 0) {
+        return {
+            appliedSeconds: 0,
+            effectiveSeconds: Math.min(declaredFrames, overlapFrames) / fps,
+            appliedFrames: 0,
+            outcome: 'already-overlapping'
+        };
+    }
+    const maximumFrames = input.maxExtendSeconds === Number.POSITIVE_INFINITY
+        ? Number.POSITIVE_INFINITY
+        : Number.isFinite(input.maxExtendSeconds) && input.maxExtendSeconds > 0
+            ? Math.max(0, Math.floor(input.maxExtendSeconds * fps + 1e-9)) : 0;
+    // すき間（負の overlapFrames）がある場合は、その穴を埋めたうえで宣言尺ぶん重ねる。
+    // UI は非隣接ガードでこの経路へ入れないが、純関数としては安全な値を返す。
+    const requiredFrames = Math.max(0, declaredFrames - overlapFrames);
+    const appliedFrames = Math.min(requiredFrames, maximumFrames);
+    const effectiveFrames = Math.max(0, Math.min(declaredFrames, overlapFrames + appliedFrames));
+    return {
+        appliedSeconds: appliedFrames / fps,
+        effectiveSeconds: effectiveFrames / fps,
+        appliedFrames,
+        outcome: appliedFrames <= 0 ? 'none'
+            : appliedFrames >= requiredFrames ? 'full' : 'partial'
+    };
+}
 /**
  * ギャップ 0、または earlier の宣言済み transitionOut.duration で説明できる重なりだけを
  * 隣接とみなす。秒の誤差ではなく、出力 fps で量子化したフレーム数を比較する。
  */
 function areCutsAdjacent(earlier, later, fps = DEFAULT_CUT_ADJACENCY_FPS) {
-    const resolvedFps = effectiveFps(fps);
-    const earlierEndFrame = Math.round(earlier.tlEnd * resolvedFps);
-    const laterStartFrame = Math.round(later.tlStart * resolvedFps);
-    const overlapFrames = earlierEndFrame - laterStartFrame;
+    const resolvedFps = effectiveCutFps(fps);
+    const overlapFrames = cutOverlapFrames(earlier, later, resolvedFps);
     const declaredDuration = earlier.transitionOut?.duration;
     const declaredOverlapFrames = typeof declaredDuration === 'number'
         && Number.isFinite(declaredDuration) && declaredDuration > 0

package/vendor/packages/edit-store/lib/edit-store.d.ts

@@ -1,3 +1,4 @@
+import { type TransitionHandleExtensionPlan } from './cut-adjacency';
 export interface EditCut {
     in: number;
     out: number;
@@ -143,6 +144,26 @@ export declare function setCutTransitionOutInSource(source: string, cutIndex: nu
     type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
     duration: number;
 } | null): string;
+export interface SetV2TransitionOutWithHandleInput {
+    itemId: string;
+    transitionOut: {
+        type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
+        duration: number;
+    };
+    earlierEndSeconds: number;
+    laterStartSeconds: number;
+    maxExtendSeconds: number;
+    fps: number;
+}
+export interface SetV2TransitionOutWithHandleResult {
+    source: string;
+    plan: TransitionHandleExtensionPlan;
+}
+/**
+ * v2 の transition_out 宣言と outgoing の source.out / duration 延長を 1 回の
+ * byte-preserving 手術で行う。maxExtendSeconds は出力秒軸の上限で、素材実尺は呼び出し側が決める。
+ */
+export declare function setV2TransitionOutWithHandleInSource(source: string, input: SetV2TransitionOutWithHandleInput): SetV2TransitionOutWithHandleResult;
 export declare function reorderCutsInSource(source: string, fromIndex: number, toIndex: number): string;
 export declare function splitCutInSource(source: string, cutIndex: number, atSeconds: number): string;
 export declare function deleteCutInSource(source: string, cutIndex: number): {

package/vendor/packages/edit-store/lib/edit-store.js

@@ -9,6 +9,7 @@ exports.setCutSpeedInSource = setCutSpeedInSource;
 exports.updateCutTransformInSource = updateCutTransformInSource;
 exports.updateCutOpacityInSource = updateCutOpacityInSource;
 exports.setCutTransitionOutInSource = setCutTransitionOutInSource;
+exports.setV2TransitionOutWithHandleInSource = setV2TransitionOutWithHandleInSource;
 exports.reorderCutsInSource = reorderCutsInSource;
 exports.splitCutInSource = splitCutInSource;
 exports.deleteCutInSource = deleteCutInSource;
@@ -37,6 +38,7 @@ exports.removeOverlayInSource = removeOverlayInSource;
 exports.writeTimelineTracksInSource = writeTimelineTracksInSource;
 exports.updateArrayElementByIndex = updateArrayElementByIndex;
 exports.updateOverlayVarInSource = updateOverlayVarInSource;
+const cut_adjacency_1 = require("./cut-adjacency");
 const JSON_NUMBER = '-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?';
 const LAYER_BLEND_MODES = [
     'normal', 'screen', 'multiply', 'add', 'difference',
@@ -348,6 +350,104 @@ function setCutTransitionOutInSource(source, cutIndex, transitionOut) {
         }
     });
 }
+/**
+ * v2 の transition_out 宣言と outgoing の source.out / duration 延長を 1 回の
+ * byte-preserving 手術で行う。maxExtendSeconds は出力秒軸の上限で、素材実尺は呼び出し側が決める。
+ */
+function setV2TransitionOutWithHandleInSource(source, input) {
+    const raw = JSON.parse(source);
+    if (raw.version !== 2) {
+        throw new Error('v2 へ変換してから編集してください。');
+    }
+    assertTransitionOutValue(input.transitionOut);
+    if (!input.itemId) {
+        throw new Error('トランジション対象のアイテム id が空です。');
+    }
+    const tracks = locateArray(source, 'tracks');
+    const trackElements = splitTopLevelElements(tracks.inner);
+    const matches = [];
+    for (const track of trackElements) {
+        let items;
+        try {
+            items = locateArray(track.text, 'items');
+        }
+        catch {
+            continue;
+        }
+        const item = splitTopLevelElements(items.inner)
+            .find(candidate => readStringProperty(candidate.text, 'id') === input.itemId);
+        if (item)
+            matches.push({ track, items, item });
+    }
+    if (matches.length !== 1) {
+        throw new Error(matches.length === 0
+            ? `アイテム ${input.itemId} が見つかりません`
+            : `アイテム ${input.itemId} が複数あります`);
+    }
+    const match = matches[0];
+    const label = `アイテム ${input.itemId}`;
+    const durationFrames = readNumberProperty(match.item.text, 'duration', label);
+    const mediaSource = locateTopLevelObjectProperty(match.item.text, 'source');
+    if (readStringProperty(mediaSource.text, 'kind') !== 'media') {
+        throw new Error(`${label} は映像素材ではありません。`);
+    }
+    const sourceIn = readNumberProperty(mediaSource.text, 'in', label);
+    const sourceOut = readNumberProperty(mediaSource.text, 'out', label);
+    const outputDurationSeconds = durationFrames / input.fps;
+    const speed = (sourceOut - sourceIn) / outputDurationSeconds;
+    // 暗黙 speed を維持できない極端値は、素材窓を壊すより宣言だけを残す保守側へ倒す。
+    // 実用域外（1e-6 未満 / 1e6 超）の比率も浮動小数の増分が不安定なので延長しない。
+    const safeSpeed = Number.isFinite(speed) && speed >= 1e-6 && speed <= 1e6;
+    const plan = (0, cut_adjacency_1.planTransitionHandleExtension)({
+        declaredSeconds: input.transitionOut.duration,
+        earlierEndSeconds: input.earlierEndSeconds,
+        laterStartSeconds: input.laterStartSeconds,
+        maxExtendSeconds: safeSpeed ? input.maxExtendSeconds : 0,
+        fps: input.fps
+    });
+    let nextMediaSource = writeTransitionOutProperty(mediaSource.text, input.transitionOut);
+    if (plan.appliedFrames > 0) {
+        const nextOut = sourceOut + plan.appliedSeconds * speed;
+        if (!Number.isFinite(nextOut)) {
+            throw new Error(`${label} の out を安全に延長できません。`);
+        }
+        nextMediaSource = replaceNumberProperty(nextMediaSource, 'out', nextOut, label);
+    }
+    let nextItem = match.item.text.slice(0, mediaSource.start)
+        + nextMediaSource
+        + match.item.text.slice(mediaSource.end);
+    if (plan.appliedFrames > 0) {
+        nextItem = replaceNumberProperty(nextItem, 'duration', durationFrames + plan.appliedFrames, label);
+    }
+    const nextTrack = replaceElement(match.track.text, match.items.openIndex + 1, match.item, nextItem);
+    return {
+        source: replaceElement(source, tracks.openIndex + 1, match.track, nextTrack),
+        plan
+    };
+}
+function assertTransitionOutValue(transitionOut) {
+    if (transitionOut.type !== 'dissolve' && transitionOut.type !== 'fade-black'
+        && transitionOut.type !== 'fade-white' && transitionOut.type !== 'reveal-down'
+        && transitionOut.type !== 'reveal-up') {
+        throw new Error('トランジションの種別が不正です。');
+    }
+    if (!Number.isFinite(transitionOut.duration) || transitionOut.duration <= 0) {
+        throw new Error('トランジションの尺は正の数で指定してください。');
+    }
+}
+function writeTransitionOutProperty(mediaSource, transitionOut) {
+    const value = { type: transitionOut.type, duration: transitionOut.duration };
+    if (!hasTopLevelProperty(mediaSource, 'transition_out')) {
+        return appendJsonProperty(mediaSource, 'transition_out', value);
+    }
+    try {
+        const located = locateTopLevelObjectProperty(mediaSource, 'transition_out');
+        return mediaSource.slice(0, located.start) + JSON.stringify(value) + mediaSource.slice(located.end);
+    }
+    catch {
+        return appendJsonProperty(removeObjectProperty(mediaSource, 'transition_out'), 'transition_out', value);
+    }
+}
 function reorderCutsInSource(source, fromIndex, toIndex) {
     const array = locateArray(source, 'cuts');
     const elements = splitTopLevelElements(array.inner);

package/vendor/packages/edit-store/lib/internal-model.d.ts

@@ -167,6 +167,19 @@ export declare function readInternalSources(source: string | unknown): InternalS
  * 検証される側であり、検証対象自身を尺の分母に混ぜると常に「収まっている」判定になってしまう。
  */
 export declare function visualContentEndSeconds(internal: InternalEdit): number;
+export interface CrossTrackLayerEvacuation {
+    itemId: string;
+    trackId: string;
+    causeItemId: string;
+    causeTrackId: string;
+    overlapStartFrames: number;
+    overlapEndFrames: number;
+}
+/**
+ * 別 visual track との重なりが原因で upper item が layers へ退避される組を返す。
+ * edit-lint と UI は理由文言に必要な相手 id を、この単一定義から得る。
+ */
+export declare function findCrossTrackLayerEvacuations(edit: unknown): CrossTrackLayerEvacuation[];
 export interface LegacyEditView {
     cuts: EditCut[];
     sources?: EditSource[];

package/vendor/packages/edit-store/lib/internal-model.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readInternalEdit = readInternalEdit;
 exports.readInternalSources = readInternalSources;
 exports.visualContentEndSeconds = visualContentEndSeconds;
+exports.findCrossTrackLayerEvacuations = findCrossTrackLayerEvacuations;
 exports.projectLegacyEdit = projectLegacyEdit;
 exports.toLegacyTrack = toLegacyTrack;
 exports.derivedLegacyTracks = derivedLegacyTracks;
@@ -258,26 +259,16 @@ function needsLayersEngine(item, chromaKeyOf, hasOverlappingSibling = false) {
         return true;
     return false;
 }
-// P0 2026-08-23 cuts-cross-track-overlap: 'cuts' 経路は同一トラック内の同時表示だけでなく、
-// 別トラック間の同時表示も winner-take-all になり、下段を描画できない。全 visual トラックの
-// items[] を総当りで比較し、半開区間 [at, at+duration) が正の長さで交差する media アイテムを
-// layers へ退避する。終端と開始が接するだけなら交差ではない。同一トラックの交差は両方を
-// layers へ送る。別トラックの交差は、下段を cuts の不透明な基底として残し、上段が全画面不透明
-// ではない宣言を持つときだけ layers へ送る。上段が全画面不透明なら winner-take-all でも同じ絵に
-// なるため、従来の cuts / track-stack 経路を保つ。
-//
-// transition_out は同一トラックの隣接カットが意図的に作る狭い重なりで、cuts/xfade が表現する。
-// その例外は同一トラックのペアだけに適用する。別トラックとの交差は transition の有無にかかわらず
-// 真の同時表示なので layers へ退避する。
-function computeOverlappingItemIds(itemGroups) {
+function analyzeOverlappingItems(itemGroups) {
     const overlapping = new Set();
-    const entries = itemGroups.flatMap((items, trackIndex) => items.map(item => ({ item, trackIndex })));
+    const crossTrackEvacuations = [];
+    const entries = itemGroups.flatMap((group, trackIndex) => group.items.map(item => ({ item, trackIndex, trackId: group.trackId })));
     for (let i = 0; i < entries.length; i++) {
-        const { item: a, trackIndex: aTrackIndex } = entries[i];
+        const { item: a, trackIndex: aTrackIndex, trackId: aTrackId } = entries[i];
         if (a.source.kind !== 'media')
             continue;
         for (let j = i + 1; j < entries.length; j++) {
-            const { item: b, trackIndex: bTrackIndex } = entries[j];
+            const { item: b, trackIndex: bTrackIndex, trackId: bTrackId } = entries[j];
             if (b.source.kind !== 'media')
                 continue;
             if (!(a.at < b.at + b.duration && b.at < a.at + a.duration))
@@ -291,13 +282,40 @@ function computeOverlappingItemIds(itemGroups) {
                 overlapping.add(b.id);
             }
             else {
-                const upper = aTrackIndex > bTrackIndex ? a : b;
-                if (needsCrossTrackLayers(upper))
+                const upperIsA = aTrackIndex > bTrackIndex;
+                const upper = upperIsA ? a : b;
+                const lower = upperIsA ? b : a;
+                if (needsCrossTrackLayers(upper)) {
                     overlapping.add(upper.id);
+                    crossTrackEvacuations.push({
+                        itemId: upper.id,
+                        trackId: upperIsA ? aTrackId : bTrackId,
+                        causeItemId: lower.id,
+                        causeTrackId: upperIsA ? bTrackId : aTrackId,
+                        overlapStartFrames: Math.max(a.at, b.at),
+                        overlapEndFrames: Math.min(a.at + a.duration, b.at + b.duration)
+                    });
+                }
             }
         }
     }
-    return overlapping;
+    return { itemIds: overlapping, crossTrackEvacuations };
+}
+function computeOverlappingItemIds(itemGroups) {
+    return analyzeOverlappingItems(itemGroups.map((items, index) => ({
+        items,
+        trackId: String(index)
+    }))).itemIds;
+}
+/**
+ * 別 visual track との重なりが原因で upper item が layers へ退避される組を返す。
+ * edit-lint と UI は理由文言に必要な相手 id を、この単一定義から得る。
+ */
+function findCrossTrackLayerEvacuations(edit) {
+    const parsed = (0, edit_v2_1.readEditV2)(edit);
+    return analyzeOverlappingItems(parsed.tracks.flatMap(track => track.lane === 'visual' && 'items' in track
+        ? [{ items: track.items, trackId: track.id }]
+        : [])).crossTrackEvacuations;
 }
 // cuts の winner-take-all が下段を隠してよいのは、上段が全画面を不透明に覆う場合だけ。
 // transform の単位元を明示しただけなら従来経路を維持する。crop / 半透明 / keyframes は、

package/vendor/packages/project-scaffold/src/index.mjs

@@ -31,6 +31,7 @@ const FALLBACK_CLAUDE_GUIDANCE = [
     '- 編集スキルは `.claude/skills/` にあり、`/analyze-footage` などの素の名前で使えます。',
     '- Codex や Cursor など他の AI エージェント用の入り口が `.agents/skills/`、`.cursor/skills/`、`.codex/skills/` にあります（中身は `.claude/skills/` へのリンク）。',
     '- `.akari/intake.json` の `status` が `submitted` なら、そこに書かれた `tasks` / `target` / `autonomy` に従って進めます。`autonomy` が `checkpoint`（既定）なら、企画の承認や書き出し前などの要所で必ず人に確認します。`status` が `draft` のときは進め方がまだ決まっていないので、フォームや対話で確定させてから作業を始めます。',
+    '- 進め方を `.akari/intake.json` に書くときは、`tasks` は決められた 5 つの id だけを使い、`target` は `duration_s` か `keep_length: true` のどちらか片方にします。`status` を `submitted` にする前に lint で確認します。',
     '- 利用者へは日本語で、内部の仕組みではなく「変更履歴」「企画メモ」「素材」などの言葉で説明します。',
     '',
     'このファイルはあなたのプロジェクトのものです。自由に書き換えて構いません。',
@@ -52,6 +53,8 @@ const FALLBACK_AGENT_GUIDANCE = [
     '`.akari/intake.json` の `status` が `submitted` なら `tasks` / `target` / `autonomy` に従って進める。',
     '`autonomy: checkpoint`（既定）なら企画承認・書き出し前などの要所で人に確認する。',
     '`status: draft` なら進め方が未確定のため、フォームまたは対話で確定させてから進める。',
+    '進め方を `.akari/intake.json` に書くときは、`tasks` は決められた 5 つの id だけを使い、`target` は `duration_s` か `keep_length: true` のどちらか片方にする。',
+    '`status` を `submitted` にする前に lint で確認する。',
     '',
     '利用者へは日本語で、内部の仕組みではなく役割が伝わる言葉を使う。',
     'この案内はこのプロジェクトのものです。自由に書き換えて構いません。',

package/vendor/packages/project-scaffold/test/create-project.test.mjs

@@ -51,6 +51,14 @@ test("bare template: scaffold generates a draft .akari/intake.json and a CLAUDE.
     assert.match(claudeMd, /submitted/);
     assert.match(claudeMd, /draft/);
     assert.match(claudeMd, /checkpoint/);
+    assert.match(claudeMd, /`tasks` は決められた 5 つの id だけ/);
+    assert.match(claudeMd, /`duration_s` か `keep_length: true` のどちらか片方/);
+    assert.match(claudeMd, /`submitted` にする前に lint で確認/);
+
+    const agentsMd = await readFile(join(destination, "AGENTS.md"), "utf8");
+    assert.match(agentsMd, /`tasks` は決められた 5 つの id だけ/);
+    assert.match(agentsMd, /`duration_s` か `keep_length: true` のどちらか片方/);
+    assert.match(agentsMd, /`submitted` にする前に lint で確認/);
 
     assert.ok(report.fallback.writtenFiles.includes(".akari/intake.json"));
     assert.ok(report.fallback.writtenFiles.includes("CLAUDE.md"));

package/vendor/skills/create-project/SKILL.md

@@ -64,3 +64,24 @@ akari new <target-dir> [--template <path>]
 ## intake.json（進め方フォームの保存先）
 
 作成直後の `.akari/intake.json` は `status: "draft"`・空 `tasks` から始まる（契約: `packages/schemas/intake.schema.json`）。プロジェクトの CLAUDE.md には intake の規律を追記する — `status: "submitted"` なら `tasks` / `target` / `autonomy` に従い、`autonomy: "checkpoint"`（既定）なら企画承認・書き出し前などの要所で人に確認し、`status: "draft"` のままなら進め方をフォームまたは対話で確定させてから進める。
+
+- `tasks` は次の固定語彙のみを使う。日本語ラベルの正本は契約正本の `x-akari-labels` とする
+  - `transcribe-captions`（文字起こし・テロップ）
+  - `silence-cut`（いらない間・NG のカット）
+  - `bgm-sfx`（BGM・効果音）
+  - `narration`（ナレーション（自分の声 / 既製の声））
+  - `3d-inserts`（3D・画面はめ込みの演出）
+- 依頼文・自由文を `tasks` に入れない。語彙に無い要望は `tasks` に書かず、
+  `target.taste`（自由記述）や `planning/` 側へ置く
+- `target.duration_s`（数値指定）と `target.keep_length: true`（尺維持）はどちらか片方にする。
+  「約60秒にする」なら `{"duration_s": 60, "keep_length": false}`、「尺は変えない」なら
+  `{"duration_s": null, "keep_length": true}` とする
+- `status` を `"submitted"` へ変える前に、リポジトリルートから edit-lint スキルと同じ CLI を
+  実行し、`intake.*` の error finding が無いことを確認する。`submitted` にするときは
+  `submitted_at` に ISO 8601 日時を必ず入れる
+
+  ```sh
+  node packages/edit-lint/bin/edit-lint.mjs <project-root>
+  ```
+
+フィールドの契約正本は `packages/schemas/intake.schema.json` とする。

package/vendor/templates/project-default/AGENTS.md

@@ -13,6 +13,8 @@
   従って進める。`autonomy: checkpoint`（既定）なら企画承認・書き出し前などの要所で
   利用者に確認する。`status: draft` なら進め方が未確定のため、フォームまたは対話で
   確定させてから進める。
+- 進め方を `.akari/intake.json` に書くときは、`tasks` は決められた 5 つの id だけを使い、`target` は `duration_s` か `keep_length: true` のどちらか片方にする。
+  `status` を `submitted` にする前に lint で確認する。
 - プロジェクトルート直下に新規ファイルを作らない（`edit.json` 等の既存契約ファイルを除く）。
   生成物は `.akari/work/`、証跡は `.akari/reports/`、キャッシュは `.akari/cache/` に置く。
   詳しい層の定義は `docs/contract-2026-07-25-project-structure-v0.md`（本モノレポ側）を参照する。

package/vendor/templates/project-default/CLAUDE.md

@@ -19,6 +19,8 @@
 要所で必ず利用者に確認します。`status` が `draft` のときは進め方がまだ決まっていないので、
 フォームまたは対話で確定させてから作業を始めます。
 
+進め方を `.akari/intake.json` に書くときは、`tasks` は決められた 5 つの id だけを使い、`target` は `duration_s` か `keep_length: true` のどちらか片方にします。`status` を `submitted` にする前に lint で確認します。
+
 素材が足りないときは、`akari assets list` でアカウントの素材ライブラリ（無料全部 + 購入済み）を
 確認できます。使いたい素材が見つかったら `akari assets fetch <id> --project .` でこのプロジェクトへ
 取り込みます（sha256 検証込み）。有料素材は `akari store connect` で接続済みのアカウントで