@event4u/agent-config 5.10.0 → 6.0.0

package/scripts/ai-video/stitch.sh

@@ -1,154 +0,0 @@
-#!/usr/bin/env bash
-# stitch.sh — ffmpeg-based clip concatenator for /video:* pipelines.
-#
-# Drives the cut from <project>/manifest.json (an ordered array of
-# `{scene_id, clip_path, audio_embedded, audio_path?, duration}`).
-# Pass-through for audio_embedded=true; ffmpeg mux for audio_embedded
-# =false; operator-supplied bed for video-only clips.
-#
-# Usage:
-#   stitch.sh <manifest.json> <output.mp4>
-#               [--skip-scene <id> ...]
-#               [--abort-on-missing | --continue]
-#               [--crossfade <seconds>]
-#
-# Failure semantics:
-#   - Missing clip → fail loud with scene_id and re-render hint
-#     unless --skip-scene <id> drops the clip from the cut or
-#     --continue is passed (the dropped scenes are written to stderr).
-#   - --abort-on-missing is the default.
-#   - Adapter-failure rollback contract: a failed adapter writes
-#     <project>/scenes/<id>/error.json; stitch.sh checks for that
-#     file alongside the clip and surfaces it instead of an opaque
-#     ffmpeg error.
-
-set -euo pipefail
-
-# shellcheck source=lib/adapter-common.sh
-. "$(dirname "$0")/lib/adapter-common.sh"
-
-aiv_require_cmd jq
-
-DRYRUN="${AIV_DRYRUN:-true}"
-case "${DRYRUN}" in
-  false|FALSE|0|no|NO) DRYRUN_FLAG=0 ;;
-  *) DRYRUN_FLAG=1 ;;
-esac
-[ "${DRYRUN_FLAG}" -eq 0 ] && aiv_require_cmd ffmpeg
-
-MANIFEST="${1:-}"
-OUTPUT="${2:-}"
-[ -n "${MANIFEST}" ] && [ -n "${OUTPUT}" ] \
-  || aiv_die 2 "usage: stitch.sh <manifest.json> <output.mp4> [--skip-scene <id>] [--abort-on-missing|--continue] [--crossfade <s>]"
-[ -r "${MANIFEST}" ] || aiv_die 2 "manifest not readable: ${MANIFEST}"
-shift 2 || true
-
-SKIP_IDS=""
-MISSING_POLICY="abort"
-CROSSFADE=""
-while [ "$#" -gt 0 ]; do
-  case "$1" in
-    --skip-scene) SKIP_IDS="${SKIP_IDS} ${2:-}"; shift 2 ;;
-    --abort-on-missing) MISSING_POLICY="abort"; shift ;;
-    --continue) MISSING_POLICY="continue"; shift ;;
-    --crossfade) CROSSFADE="${2:-}"; shift 2 ;;
-    *) aiv_die 2 "stitch.sh: unknown flag '$1'" ;;
-  esac
-done
-
-skip_match() {
-  local id="$1" s
-  for s in ${SKIP_IDS}; do
-    [ "${s}" = "${id}" ] && return 0
-  done
-  return 1
-}
-
-PROJECT_DIR="$(cd "$(dirname "${MANIFEST}")" && pwd)"
-WORK_DIR="$(mktemp -d -t aiv-stitch-XXXXXX)"
-trap 'rm -rf "${WORK_DIR}"' EXIT
-CONCAT_LIST="${WORK_DIR}/concat.txt"
-: > "${CONCAT_LIST}"
-
-# Accept both bare-array manifests and the documented object shape
-# (`{ "scenes": [...] }`). Field names tolerate the legacy
-# `scene_id` / `clip_path` keys and the example `id` / `expected_clip`.
-SCENES_JQ='if type == "array" then .[] else .scenes[] end'
-
-count=0
-missing=0
-plan=""
-while IFS= read -r row; do
-  [ -n "${row}" ] || continue
-  scene_id="$(printf '%s' "${row}" | jq -r '.scene_id // .id')"
-  clip_path="$(printf '%s' "${row}" | jq -r '.clip_path // .expected_clip')"
-  audio_embedded="$(printf '%s' "${row}" | jq -r '.audio_embedded // false')"
-  audio_path="$(printf '%s' "${row}" | jq -r '.audio_path // empty')"
-
-  case "${clip_path}" in
-    /*) ;;
-    *) clip_path="${PROJECT_DIR}/${clip_path}" ;;
-  esac
-
-  if skip_match "${scene_id}"; then
-    printf 'stitch: skip scene=%s (operator --skip-scene)\n' "${scene_id}" >&2
-    continue
-  fi
-
-  if [ "${DRYRUN_FLAG}" -eq 1 ]; then
-    plan="${plan}${scene_id}\taudio_embedded=${audio_embedded}\t${clip_path}\n"
-    count=$((count + 1))
-    continue
-  fi
-
-  if [ ! -f "${clip_path}" ]; then
-    err_json="${PROJECT_DIR}/scenes/${scene_id}/error.json"
-    if [ -f "${err_json}" ]; then
-      printf 'stitch: scene=%s adapter-error: ' "${scene_id}" >&2
-      jq -r '"adapter=\(.adapter) exit=\(.exit_code) user_action=\(.user_action)"' "${err_json}" >&2
-    fi
-    if [ "${MISSING_POLICY}" = "continue" ]; then
-      printf 'stitch: continue past missing scene=%s clip=%s (re-render or --skip-scene next time)\n' \
-        "${scene_id}" "${clip_path}" >&2
-      missing=$((missing + 1))
-      continue
-    fi
-    aiv_die 7 "missing clip for scene=${scene_id} at ${clip_path} (re-render the scene, pass --skip-scene ${scene_id}, or use --continue)"
-  fi
-
-  # For clips without embedded audio that ship a sibling track, mux
-  # via ffmpeg into a tmp file before concat. Pure pass-through for
-  # the embedded-audio case.
-  if [ "${audio_embedded}" = "false" ] && [ -n "${audio_path}" ] && [ -f "${audio_path}" ]; then
-    muxed="${WORK_DIR}/${scene_id}.mp4"
-    ffmpeg -loglevel error -y -i "${clip_path}" -i "${audio_path}" \
-      -c:v copy -c:a aac -shortest "${muxed}" >/dev/null \
-      || aiv_die 8 "ffmpeg mux failed for scene=${scene_id}"
-    printf "file '%s'\n" "${muxed}" >> "${CONCAT_LIST}"
-  else
-    printf "file '%s'\n" "${clip_path}" >> "${CONCAT_LIST}"
-  fi
-  count=$((count + 1))
-done <<EOF
-$(jq -c "${SCENES_JQ}" "${MANIFEST}")
-EOF
-
-[ "${count}" -gt 0 ] || aiv_die 7 "stitch: no usable clips after manifest scan (missing=${missing}, skipped via --skip-scene)"
-
-if [ "${DRYRUN_FLAG}" -eq 1 ]; then
-  printf 'stitch: dry-run plan (output=%s, scenes=%d):\n' "${OUTPUT}" "${count}" >&2
-  printf '%b' "${plan}" >&2
-  printf '{"output":"%s","scenes":%d,"missing":0,"dry_run":true}\n' "${OUTPUT}" "${count}"
-  exit 0
-fi
-
-if [ -n "${CROSSFADE}" ]; then
-  printf 'stitch: crossfade=%ss requested — passing through ffmpeg xfade filter not yet implemented (concat path used)\n' \
-    "${CROSSFADE}" >&2
-fi
-
-ffmpeg -loglevel error -y -f concat -safe 0 -i "${CONCAT_LIST}" \
-  -c copy "${OUTPUT}" >/dev/null \
-  || aiv_die 8 "ffmpeg concat failed (manifest=${MANIFEST}, output=${OUTPUT})"
-
-printf '{"output":"%s","scenes":%d,"missing":%d}\n' "${OUTPUT}" "${count}" "${missing}"

package/scripts/ai-video/test-pipeline.sh

@@ -1,169 +0,0 @@
-#!/usr/bin/env bash
-# test-pipeline.sh — offline smoke test for /video:* against
-# agents/reference/ai-video/examples/banana-arc/. Dry-run only; no network.
-#
-# Asserts (per agents/roadmaps/ai-video-pipeline.md Phase 6 Step 3):
-#   1. parse-blueprint.sh output matches the committed expected.json
-#      per scene (3 scenes, 3 tiers).
-#   2. character.json descriptor tokens (silhouette, palette, wardrobe,
-#      prop) appear verbatim in each scene's prompt.subject — the
-#      load-bearing character-lock substring assertion.
-#   3. audio.* branching is correct: scene 2 → enable_native_audio=true,
-#      scenes 1+3 → false.
-#   4. native-audio-capable adapter (gemini-veo) advertises capability
-#      audio=native; non-audio adapter (openai-images) advertises
-#      audio=none; stitch.sh sees audio_embedded per scene.
-#   5. stitch.sh dry-run returns the committed manifest's stitch_output
-#      path without invoking ffmpeg or any network.
-#   6. visual regression: each scene's locked.png is non-empty + has
-#      PNG magic; pairwise NCC ≥ 0.95 when `compare` is available.
-#      When unavailable, asserts byte-identity (the three frames are
-#      committed identical for the offline path).
-#
-# Exit 0 = all assertions pass; 1 = at least one failure (counted +
-# summarized at the end).
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-PROJECT="$ROOT/agents/reference/ai-video/examples/banana-arc"
-
-PASS=0
-FAIL=0
-FAILS=""
-
-ok()   { PASS=$((PASS+1)); printf '  ✅  %s\n' "$1"; }
-fail() { FAIL=$((FAIL+1)); FAILS="$FAILS\n  ❌  $1"; printf '  ❌  %s\n' "$1"; }
-
-require() {
-  if command -v "$1" >/dev/null 2>&1; then return 0; fi
-  fail "required tool missing: $1"
-  return 1
-}
-
-require jq || exit 1
-
-printf '\n== test-pipeline.sh — banana-arc golden run (offline) ==\n\n'
-
-# ---------------------------------------------------------------- 1
-printf '[1/6] parse-blueprint vs. expected.json\n'
-SCENES="01-simple 02-dialogue-native-audio 03-edge-duration"
-for s in $SCENES; do
-  actual="$(bash "$ROOT/scripts/ai-video/lib/parse-blueprint.sh" "$PROJECT/scenes/$s/blueprint.txt" 2>/dev/null \
-    | jq -S . 2>/dev/null || true)"
-  expected="$(jq -S . "$PROJECT/scenes/$s/expected.json" 2>/dev/null || true)"
-  if [ -z "$actual" ]; then
-    fail "$s: parse-blueprint produced no output"
-  elif [ "$actual" = "$expected" ]; then
-    ok "$s: parse-blueprint matches expected.json"
-  else
-    fail "$s: parse-blueprint mismatch (diff actual vs. expected.json)"
-  fi
-done
-
-# ---------------------------------------------------------------- 2
-printf '\n[2/6] character.json descriptors verbatim in prompt.subject\n'
-SILHOUETTE="$(jq -r '.characters[0].silhouette' "$PROJECT/character.json")"
-PALETTE="$(jq -r '.characters[0].palette'    "$PROJECT/character.json")"
-WARDROBE="$(jq -r '.characters[0].wardrobe'  "$PROJECT/character.json")"
-PROP="$(jq -r '.characters[0].prop'          "$PROJECT/character.json")"
-
-for s in $SCENES; do
-  subj="$(jq -r '.prompt.subject' "$PROJECT/scenes/$s/expected.json")"
-  miss=""
-  case "$subj" in *"$SILHOUETTE"*) :;; *) miss="$miss silhouette";; esac
-  case "$subj" in *"$PALETTE"*)    :;; *) miss="$miss palette";; esac
-  case "$subj" in *"$WARDROBE"*)   :;; *) miss="$miss wardrobe";; esac
-  case "$subj" in *"$PROP"*)       :;; *) miss="$miss prop";; esac
-  if [ -z "$miss" ]; then
-    ok "$s: silhouette + palette + wardrobe + prop verbatim in prompt.subject"
-  else
-    fail "$s: missing verbatim tokens in prompt.subject:$miss"
-  fi
-done
-
-# ---------------------------------------------------------------- 3
-printf '\n[3/6] audio.* branching matches manifest\n'
-for entry in 01-simple:false 02-dialogue-native-audio:true 03-edge-duration:false; do
-  s="${entry%%:*}"
-  want="${entry##*:}"
-  got="$(jq -r '.audio.enable_native_audio' "$PROJECT/scenes/$s/expected.json")"
-  manifest_got="$(jq -r --arg id "$s" '.scenes[] | select(.id==$id) | .audio_embedded' "$PROJECT/manifest.json")"
-  if [ "$got" = "$want" ] && [ "$manifest_got" = "$want" ]; then
-    ok "$s: enable_native_audio=$got, manifest.audio_embedded=$manifest_got"
-  else
-    fail "$s: audio branching drift (expected=$want, blueprint=$got, manifest=$manifest_got)"
-  fi
-done
-
-# ---------------------------------------------------------------- 4
-printf '\n[4/6] adapter capability declarations\n'
-declare_caps() {
-  local adapter="$1"; local expected="$2"
-  local out got
-  out="$(AIV_DRYRUN=true bash "$ROOT/scripts/ai-video/adapters/$adapter.sh" capability 2>/dev/null || true)"
-  got="$(printf '%s' "$out" | jq -r '.audio // empty' 2>/dev/null || true)"
-  if [ "$got" = "$expected" ]; then
-    ok "$adapter: capability.audio=$got"
-  else
-    fail "$adapter: capability mismatch (want audio=$expected, got: ${got:-<unparseable: $out>})"
-  fi
-}
-declare_caps gemini-veo    "native"
-declare_caps openai-images "none"
-declare_caps sora          "native"
-declare_caps kling         "none"
-
-# ---------------------------------------------------------------- 5
-printf '\n[5/6] stitch.sh dry-run returns manifest output path\n'
-STITCH_OUT="$(jq -r '.stitch_output' "$PROJECT/manifest.json")"
-stitch_log="$(AIV_DRYRUN=true bash "$ROOT/scripts/ai-video/stitch.sh" \
-  "$PROJECT/manifest.json" "$PROJECT/$STITCH_OUT" 2>&1 || true)"
-case "$stitch_log" in
-  *"$STITCH_OUT"*) ok   "stitch.sh dry-run referenced $STITCH_OUT";;
-  *)               fail "stitch.sh dry-run did not reference $STITCH_OUT (log: $stitch_log)";;
-esac
-
-# ---------------------------------------------------------------- 6
-printf '\n[6/6] visual regression (locked.png pairwise)\n'
-PNG_MAGIC="$(printf '\x89PNG\r\n\x1a\n')"
-prev=""
-have_compare=0
-command -v compare >/dev/null 2>&1 && have_compare=1
-for s in $SCENES; do
-  f="$PROJECT/scenes/$s/fixtures/frames/locked.png"
-  if [ ! -s "$f" ]; then
-    fail "$s: locked.png missing or empty"
-    continue
-  fi
-  head -c 8 "$f" | od -An -c | tr -d ' \n' | grep -q '211PNG' \
-    && ok "$s: locked.png is a valid PNG ($(wc -c < "$f" | tr -d ' ') bytes)" \
-    || fail "$s: locked.png lacks PNG magic"
-  if [ -n "$prev" ]; then
-    if [ "$have_compare" -eq 1 ]; then
-      ncc="$(compare -metric NCC "$prev" "$f" null: 2>&1 || true)"
-      awk_ok="$(awk -v v="$ncc" 'BEGIN { exit !(v+0 >= 0.95) }' && echo yes || echo no)"
-      if [ "$awk_ok" = "yes" ]; then
-        ok "$s: NCC vs. previous = $ncc (≥ 0.95)"
-      else
-        fail "$s: NCC vs. previous = $ncc (< 0.95)"
-      fi
-    else
-      if cmp -s "$prev" "$f"; then
-        ok "$s: byte-identical to previous (compare unavailable; offline fallback)"
-      else
-        fail "$s: differs from previous frame and compare is unavailable"
-      fi
-    fi
-  fi
-  prev="$f"
-done
-
-# ----------------------------------------------------------------
-printf '\n----------------\nresult: %d passed · %d failed\n' "$PASS" "$FAIL"
-if [ "$FAIL" -gt 0 ]; then
-  printf '%b\n' "$FAILS"
-  exit 1
-fi
-exit 0

package/scripts/ai_council/advisors.py

@@ -1,148 +0,0 @@
-"""Thinking-style advisors — replace-mode call planning (Phase 6).
-
-When `agents/settings/.ai-council.yml` enables an advisor (e.g. `contrarian`
-bound to `member: anthropic`), the orchestrator REPLACES the matching
-plain-member call with an advisor-persona call on the same provider.
-Same total call count as a plain run; bounded extra cost beyond the
-persona-prompt token delta.
-
-This module owns:
-
-- `AdvisorPlan`  — resolved swap for a single provider (persona text,
-  display name, optional model override).
-- `plan_advisor_swap()` — walks the enabled advisors, reads their
-  persona files, and returns the per-provider plan map consumed by
-  `orchestrator.consult()` / `estimate()` and by the CLI.
-- `resolve_persona_text()` — reads a persona file with condensed-tree
-  preference and frontmatter strip.
-
-Cross-validation against the members block already ran at config load
-(`config._build_config`); this module trusts that contract and only
-enforces the **one-advisor-per-provider** rule (replace-mode invariant).
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from pathlib import Path
-
-import yaml
-
-from scripts.ai_council.config import AdvisorConfig, CouncilConfigError
-
-
-@dataclass(frozen=True)
-class AdvisorPlan:
-    """Resolved advisor swap for a single provider."""
-
-    name: str
-    display_name: str
-    member: str
-    persona_text: str
-    model_override: str | None = None
-
-
-_FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\n", re.DOTALL)
-
-
-def _split_frontmatter(raw: str) -> tuple[dict, str]:
-    """Return ``(frontmatter_dict, body)``. Missing frontmatter → ``({}, raw)``."""
-    match = _FRONTMATTER_RE.match(raw)
-    if not match:
-        return {}, raw
-    try:
-        meta = yaml.safe_load(match.group(1)) or {}
-    except yaml.YAMLError:
-        meta = {}
-    if not isinstance(meta, dict):
-        meta = {}
-    body = raw[match.end():]
-    return meta, body
-
-
-def _display_name_from(advisor_name: str, frontmatter: dict) -> str:
-    """Prefer frontmatter ``role``; fall back to titleized advisor key."""
-    role = frontmatter.get("role")
-    if isinstance(role, str) and role.strip():
-        return role.strip()
-    return advisor_name.replace("-", " ").replace("_", " ").title()
-
-
-def resolve_persona_text(
-    persona_path: str,
-    repo_root: Path,
-) -> tuple[str, dict]:
-    """Read a persona file, returning ``(body, frontmatter)``.
-
-    Condensed tree (``.agent-src/``) wins so production runs match the
-    same projection the rest of the package consumes. Uncondensed tree
-    (``.agent-src.uncondensed/``) is the fallback for in-repo
-    development before ``task sync`` has projected the file.
-    """
-    candidates = [
-        repo_root / ".agent-src" / persona_path,
-        repo_root / ".agent-src.uncondensed" / persona_path,
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            raw = candidate.read_text(encoding="utf-8")
-            meta, body = _split_frontmatter(raw)
-            return body.strip(), meta
-    searched = "\n  - ".join(str(c) for c in candidates)
-    raise CouncilConfigError(
-        f"Persona file not found for advisor (path={persona_path!r}). "
-        f"Searched:\n  - {searched}"
-    )
-
-
-def plan_advisor_swap(
-    advisors: dict[str, AdvisorConfig],
-    repo_root: Path,
-) -> dict[str, AdvisorPlan]:
-    """Return ``{provider_name: AdvisorPlan}`` for every ENABLED advisor.
-
-    Two enabled advisors targeting the same provider is a
-    ``CouncilConfigError`` — replace-mode runs one advisor per provider
-    so the call plan never doubles up by accident.
-    """
-    plans: dict[str, AdvisorPlan] = {}
-    for adv in advisors.values():
-        if not adv.enabled:
-            continue
-        if adv.member in plans:
-            existing = plans[adv.member].name
-            raise CouncilConfigError(
-                f"advisors.{adv.name} and advisors.{existing} both bind "
-                f"member={adv.member!r}; only one advisor per provider "
-                f"per run (replace-mode invariant)."
-            )
-        body, meta = resolve_persona_text(adv.persona, repo_root)
-        plans[adv.member] = AdvisorPlan(
-            name=adv.name,
-            display_name=_display_name_from(adv.name, meta),
-            member=adv.member,
-            persona_text=body,
-            model_override=adv.model,
-        )
-    return plans
-
-
-def build_persona_labels(
-    plans: dict[str, AdvisorPlan],
-    members: list,
-) -> dict[str, str]:
-    """Build the peer-review ``source → display_name`` map.
-
-    ``source`` is the ``provider:model`` string the peer-review
-    pipeline uses for anonymisation; ``members`` is the post-swap
-    member list (model_override already applied), so the model field
-    matches what the response carries.
-    """
-    labels: dict[str, str] = {}
-    for m in members:
-        plan = plans.get(m.name)
-        if plan is None:
-            continue
-        labels[f"{m.name}:{m.model}"] = plan.display_name
-    return labels