Deep Learning

# Deep-Learning Skill 默认配置

# === 产物生成设置 ===
# 默认生成的产物类型（用空格分隔）
# 可选: report audio slides mindmap quiz video infographic flashcards
DEFAULT_ARTIFACTS="report audio slides mindmap quiz"

# 是否生成所有可用产物类型
GENERATE_ALL=false

# === Research 模式 ===
# 默认研究模式: fast (10-20秒) | deep (深度调研)
DEFAULT_RESEARCH_MODE="deep"

# === Obsidian 集成 ===
# Obsidian Vault 路径（留空则禁用）
OBSIDIAN_VAULT_PATH="$HOME/Library/CloudStorage/OneDrive-个人/obsidian-vault"
OBSIDIAN_INBOX_FOLDER="Inbox"

# 是否在 Obsidian 中创建学习笔记
ENABLE_OBSIDIAN_INTEGRATION=true

# === 输出设置 ===
# 产物下载目录
OUTPUT_BASE_DIR="$HOME/.openclaw/workspace/deep-learning-output"

# 是否保留中间文件
KEEP_TEMP_FILES=false

# === 超时设置（秒）===
SOURCE_PROCESSING_TIMEOUT=600
RESEARCH_TIMEOUT_FAST=60
RESEARCH_TIMEOUT_DEEP=1800
ARTIFACT_TIMEOUT_REPORT=900
ARTIFACT_TIMEOUT_AUDIO=1800
ARTIFACT_TIMEOUT_SLIDES=2700
ARTIFACT_TIMEOUT_VIDEO=3600
ARTIFACT_TIMEOUT_QUIZ=900

# === 重试设置 ===
MAX_RETRY_ATTEMPTS=2
RETRY_DELAY_SECONDS=300

# === Feishu 消息设置 ===
# 发送完整报告还是仅摘要
FEISHU_SEND_FULL_REPORT=false
FEISHU_SEND_SUMMARY=true

# 是否以卡片形式发送测试题
FEISHU_INTERACTIVE_QUIZ=true

# === 日志设置 ===
LOG_LEVEL="INFO"  # DEBUG | INFO | WARN | ERROR
LOG_TO_FILE=true

#!/bin/bash
# LLM-based quality grading for Phase 4
set -euo pipefail

OUTPUT_DIR=""

while [[ $# -gt 0 ]]; do
  case $1 in
    --output) OUTPUT_DIR="$2"; shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$OUTPUT_DIR" ]] && { echo "Error: --output required"; exit 1; }

echo "🤖 LLM Quality Grading (Phase 4)"

# Check required files
REPORT="$OUTPUT_DIR/report.md"
QUIZ="$OUTPUT_DIR/quiz.md"

if [[ ! -f "$REPORT" ]]; then
  echo "❌ Missing report.md, cannot grade"
  exit 1
fi

# Read report content (first 3000 chars for context)
REPORT_CONTENT=$(head -c 3000 "$REPORT")

# Prepare grading prompt
GRADING_PROMPT="You are evaluating a NotebookLM-generated study guide.

Rate the following aspects (0-8 for accuracy, 0-6 for completeness and coherence):

**Content Accuracy (0-8):**
- Factual correctness
- No hallucinations
- Relevance to topic

**Completeness (0-6):**
- Coverage of major topics
- Adequate explanations
- Comprehensive quiz

**Coherence (0-6):**
- Logical organization
- Clear language
- Consistent flow

Report excerpt:
\`\`\`
$REPORT_CONTENT
\`\`\`

Respond ONLY with JSON:
{
  \"accuracy\": <0-8>,
  \"completeness\": <0-6>,
  \"coherence\": <0-6>,
  \"reasoning\": \"brief explanation\"
}"


# Call LLM (using OpenClaw's default model)
echo "🔄 Calling LLM for grading..."

RESPONSE=$(echo "$GRADING_PROMPT" | openclaw agent send --model anthropic/claude-sonnet-4-6 --json 2>/dev/null || echo '{"accuracy":0,"completeness":0,"coherence":0}')

# Parse scores
ACCURACY=$(echo "$RESPONSE" | jq -r '.accuracy // 0')
COMPLETENESS=$(echo "$RESPONSE" | jq -r '.completeness // 0')
COHERENCE=$(echo "$RESPONSE" | jq -r '.coherence // 0')
REASONING=$(echo "$RESPONSE" | jq -r '.reasoning // "N/A"')

PHASE4=$((ACCURACY + COMPLETENESS + COHERENCE))

echo ""
echo "📊 Quality Scores:"
echo "  Accuracy: $ACCURACY/8"
echo "  Completeness: $COMPLETENESS/6"
echo "  Coherence: $COHERENCE/6"
echo "  Phase 4 Total: $PHASE4/20"
echo ""
echo "💭 Reasoning: $REASONING"

# Update score.json
if [[ -f "$OUTPUT_DIR/score.json" ]]; then
  PREV_SCORES=$(cat "$OUTPUT_DIR/score.json")
  PHASE1=$(echo "$PREV_SCORES" | jq -r '.scores.phase1_collection')
  PHASE2=$(echo "$PREV_SCORES" | jq -r '.scores.phase2_synthesis')
  PHASE3=$(echo "$PREV_SCORES" | jq -r '.scores.phase3_generation')
  
  TOTAL=$((PHASE1 + PHASE2 + PHASE3 + PHASE4))
  PASS="false"
  [[ $TOTAL -ge 70 ]] && PASS="true"
  
  jq ".scores.phase4_quality = $PHASE4 | .scores.total = $TOTAL | .pass = $PASS" \
    "$OUTPUT_DIR/score.json" > "$OUTPUT_DIR/score.json.tmp"
  mv "$OUTPUT_DIR/score.json.tmp" "$OUTPUT_DIR/score.json"
  
  echo ""
  echo "✅ Final Score: $TOTAL/100 (Pass: $PASS)"
  echo "💾 Updated: $OUTPUT_DIR/score.json"
fi

#!/bin/bash
# Run 5 trials for a test case
set -euo pipefail

TEST_CASE=""
TOPIC=""
MATERIALS=()

while [[ $# -gt 0 ]]; do
  case $1 in
    --test-case) TEST_CASE="$2"; shift 2 ;;
    --topic) TOPIC="$2"; shift 2 ;;
    --material) MATERIALS+=("$2"); shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$TEST_CASE" ]] && { echo "Error: --test-case required"; exit 1; }
[[ -z "$TOPIC" ]] && { echo "Error: --topic required"; exit 1; }

EVAL_DIR="$HOME/.openclaw/workspace/skills/deep-learning/eval"
RESULTS_DIR="$EVAL_DIR/results/$TEST_CASE"
mkdir -p "$RESULTS_DIR"

echo "🧪 Running 5 trials for: $TEST_CASE"
echo "📝 Topic: $TOPIC"
echo "📦 Materials: ${#MATERIALS[@]}"
echo ""

PASSES=0
TOTAL_SCORE=0

for i in {1..5}; do
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  echo "🔬 Trial $i/5"
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  
  # Build material args
  MATERIAL_ARGS=""
  for mat in "${MATERIALS[@]}"; do
    MATERIAL_ARGS="$MATERIAL_ARGS --material \"$mat\""
  done
  
  # Run orchestration
  eval bash ~/.openclaw/workspace/skills/deep-learning/scripts/orchestrate.sh \
    --topic \"$TOPIC\" $MATERIAL_ARGS
  
  # Get output directory (last created)
  OUTPUT_DIR=$(ls -td ~/.openclaw/workspace/deep-learning-output/*/ | head -1)
  
  # Score trial
  bash "$EVAL_DIR/scripts/score_trial.sh" \
    --output "$OUTPUT_DIR" \
    --test-case "$TEST_CASE" \
    --trial "$i"
  
  # LLM grade
  bash "$EVAL_DIR/scripts/llm_grade.sh" --output "$OUTPUT_DIR"
  
  # Copy results
  cp "$OUTPUT_DIR/score.json" "$RESULTS_DIR/trial-$i.json"
  
  # Update stats
  SCORE=$(jq -r '.scores.total' "$RESULTS_DIR/trial-$i.json")
  PASS=$(jq -r '.pass' "$RESULTS_DIR/trial-$i.json")
  
  TOTAL_SCORE=$((TOTAL_SCORE + SCORE))
  [[ "$PASS" == "true" ]] && PASSES=$((PASSES + 1))
  
  echo ""
  echo "Trial $i: $SCORE/100 (Pass: $PASS)"
  echo ""
done


# Generate aggregate report
AVG_SCORE=$((TOTAL_SCORE / 5))
PASS_RATE=$(echo "scale=2; $PASSES / 5" | bc)

VERDICT="FAIL"
[[ $(echo "$PASS_RATE >= 0.8" | bc) -eq 1 ]] && VERDICT="PASS"

cat > "$RESULTS_DIR/aggregate.json" <<AGG
{
  "test_case": "$TEST_CASE",
  "trials": 5,
  "passes": $PASSES,
  "pass_rate": $PASS_RATE,
  "avg_score": $AVG_SCORE,
  "verdict": "$VERDICT"
}
AGG

echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "📊 Final Results"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "Test Case: $TEST_CASE"
echo "Passes: $PASSES/5"
echo "Pass Rate: $PASS_RATE"
echo "Avg Score: $AVG_SCORE/100"
echo "Verdict: $VERDICT"
echo ""
echo "📂 Results: $RESULTS_DIR"

#!/bin/bash
# Score a single trial based on output directory
set -euo pipefail

OUTPUT_DIR=""
TEST_CASE=""
TRIAL=""

while [[ $# -gt 0 ]]; do
  case $1 in
    --output) OUTPUT_DIR="$2"; shift 2 ;;
    --test-case) TEST_CASE="$2"; shift 2 ;;
    --trial) TRIAL="$2"; shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$OUTPUT_DIR" ]] && { echo "Error: --output required"; exit 1; }
[[ -z "$TEST_CASE" ]] && { echo "Error: --test-case required"; exit 1; }
[[ -z "$TRIAL" ]] && { echo "Error: --trial required"; exit 1; }

echo "📊 Scoring trial: $TEST_CASE (trial $TRIAL)"

# Initialize scores
PHASE1=0
PHASE2=0
PHASE3=0

# Phase 1: Material Collection (20 points)
if [[ -f "$OUTPUT_DIR/source_ids.txt" ]]; then
  SOURCE_COUNT=$(wc -w < "$OUTPUT_DIR/source_ids.txt")
  if [[ $SOURCE_COUNT -gt 0 ]]; then
    PHASE1=$((PHASE1 + 15))  # Upload success + processing
    echo "  ✅ Phase 1: Sources uploaded ($SOURCE_COUNT)"
  fi
fi

# Phase 2: Knowledge Synthesis (20 points)
if [[ -f "$OUTPUT_DIR/metadata.json" ]]; then
  NOTEBOOK_ID=$(jq -r '.notebook_id' "$OUTPUT_DIR/metadata.json")
  if [[ -n "$NOTEBOOK_ID" && "$NOTEBOOK_ID" != "null" ]]; then
    PHASE2=$((PHASE2 + 15))  # Notebook creation + indexing
    echo "  ✅ Phase 2: Notebook created ($NOTEBOOK_ID)"
  fi
fi

# Phase 3: Artifact Generation (40 points)
ARTIFACTS=("podcast.mp3" "slides.pdf" "report.md" "mindmap.json" "quiz.json")
ARTIFACT_SCORES=(10 10 10 5 5)
ARTIFACT_COUNT=0

for i in "${!ARTIFACTS[@]}"; do
  if [[ -f "$OUTPUT_DIR/${ARTIFACTS[$i]}" ]]; then
    PHASE3=$((PHASE3 + ${ARTIFACT_SCORES[$i]}))
    ARTIFACT_COUNT=$((ARTIFACT_COUNT + 1))
    echo "  ✅ Artifact: ${ARTIFACTS[$i]}"
  else
    echo "  ❌ Missing: ${ARTIFACTS[$i]}"
  fi
done

# Calculate subtotal (before quality assessment)
SUBTOTAL=$((PHASE1 + PHASE2 + PHASE3))

echo ""
echo "📈 Scores (before quality assessment):"
echo "  Phase 1 (Collection): $PHASE1/20"
echo "  Phase 2 (Synthesis): $PHASE2/20"
echo "  Phase 3 (Generation): $PHASE3/40"
echo "  Subtotal: $SUBTOTAL/80"
echo ""
echo "⏳ Phase 4 (Quality) requires LLM grading..."
echo "   Run: llm_grade.sh --output $OUTPUT_DIR"

# Save preliminary results
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
cat > "$OUTPUT_DIR/score.json" <<SCORE
{
  "test_case": "$TEST_CASE",
  "trial": $TRIAL,
  "timestamp": "$TIMESTAMP",
  "scores": {
    "phase1_collection": $PHASE1,
    "phase2_synthesis": $PHASE2,
    "phase3_generation": $PHASE3,
    "phase4_quality": null,
    "total": null
  },
  "artifacts_generated": $ARTIFACT_COUNT,
  "pass": null
}
SCORE

echo "💾 Saved to: $OUTPUT_DIR/score.json"

#!/bin/bash
# Config loader for deep-learning skill
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIG_DIR="${SCRIPT_DIR}/../config"

# Default values
DEEP_LEARNING_CONFIG_OBSIDIAN_PATH="${DEEP_LEARNING_CONFIG_OBSIDIAN_PATH:-$HOME/Library/CloudStorage/OneDrive-个人/obsidian-vault/Inbox}"
DEEP_LEARNING_CONFIG_ENABLE_OBSIDIAN="${DEEP_LEARNING_CONFIG_ENABLE_OBSIDIAN:-true}"
DEEP_LEARNING_CONFIG_DEFAULT_RESEARCH_MODE="${DEEP_LEARNING_CONFIG_DEFAULT_RESEARCH_MODE:-deep}"
DEEP_LEARNING_CONFIG_ARTIFACT_TIMEOUT="${DEEP_LEARNING_CONFIG_ARTIFACT_TIMEOUT:-1800}"
DEEP_LEARNING_CONFIG_ENABLE_VIDEO="${DEEP_LEARNING_CONFIG_ENABLE_VIDEO:-true}"
DEEP_LEARNING_CONFIG_ENABLE_INFOGRAPHIC="${DEEP_LEARNING_CONFIG_ENABLE_INFOGRAPHIC:-false}"
DEEP_LEARNING_CONFIG_ENABLE_FLASHCARDS="${DEEP_LEARNING_CONFIG_ENABLE_FLASHCARDS:-true}"

load_config() {
    local config_file="${CONFIG_DIR}/default.conf"
    
    if [[ -f "$config_file" ]]; then
        # Source the config file
        source "$config_file"
    fi
    
    # Environment variables override config file
    OBSIDIAN_INBOX_PATH="${OBSIDIAN_INBOX_PATH:-$DEEP_LEARNING_CONFIG_OBSIDIAN_PATH}"
    ENABLE_OBSIDIAN="${ENABLE_OBSIDIAN:-$DEEP_LEARNING_CONFIG_ENABLE_OBSIDIAN}"
    DEFAULT_RESEARCH_MODE="${DEFAULT_RESEARCH_MODE:-$DEEP_LEARNING_CONFIG_DEFAULT_RESEARCH_MODE}"
    ARTIFACT_TIMEOUT="${ARTIFACT_TIMEOUT:-$DEEP_LEARNING_CONFIG_ARTIFACT_TIMEOUT}"
    ENABLE_VIDEO="${ENABLE_VIDEO:-$DEEP_LEARNING_CONFIG_ENABLE_VIDEO}"
    ENABLE_INFOGRAPHIC="${ENABLE_INFOGRAPHIC:-$DEEP_LEARNING_CONFIG_ENABLE_INFOGRAPHIC}"
    ENABLE_FLASHCARDS="${ENABLE_FLASHCARDS:-$DEEP_LEARNING_CONFIG_ENABLE_FLASHCARDS}"
}

get_prompt_template() {
    local category="$1"
    local template_file="${CONFIG_DIR}/prompts/${category}.md"
    
    if [[ -f "$template_file" ]]; then
        cat "$template_file"
    else
        echo "# Default Prompt\n\n请总结这个主题的要点，并提供深入的分析。"
    fi
}

list_prompt_categories() {
    ls -1 "${CONFIG_DIR}/prompts/" 2>/dev/null | sed 's/\.md$//' || echo "basic"
}

export -f load_config get_prompt_template list_prompt_categories

#!/bin/bash
# Download artifacts and send via Feishu
set -euo pipefail

NOTEBOOK_ID=""
OUTPUT_DIR=""
ARTIFACT_ID=""
ARTIFACT_TYPE=""

while [[ $# -gt 0 ]]; do
  case $1 in
    --notebook) NOTEBOOK_ID="$2"; shift 2 ;;
    --output) OUTPUT_DIR="$2"; shift 2 ;;
    --artifact) ARTIFACT_ID="$2"; shift 2 ;;
    --type) ARTIFACT_TYPE="$2"; shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$NOTEBOOK_ID" ]] && { echo "Error: --notebook required"; exit 1; }
[[ -z "$OUTPUT_DIR" ]] && { echo "Error: --output required"; exit 1; }
[[ -z "$ARTIFACT_ID" ]] && { echo "Error: --artifact required"; exit 1; }
[[ -z "$ARTIFACT_TYPE" ]] && { echo "Error: --type required"; exit 1; }

echo "⬇️  Downloading $ARTIFACT_TYPE artifact..."

cd "$OUTPUT_DIR"

case "$ARTIFACT_TYPE" in
  audio)
    notebooklm download audio ./podcast.mp3 -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    echo "✅ Downloaded: podcast.mp3"
    ;;
  slides)
    notebooklm download slide-deck ./slides.pdf -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    echo "✅ Downloaded: slides.pdf"
    ;;
  report)
    notebooklm download report ./report.md -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    echo "✅ Downloaded: report.md"
    ;;
  mindmap)
    notebooklm download mind-map ./mindmap.json -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    echo "✅ Downloaded: mindmap.json"
    ;;
  quiz)
    notebooklm download quiz ./quiz.json -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    notebooklm download quiz --format markdown ./quiz.md -a "$ARTIFACT_ID" -n "$NOTEBOOK_ID"
    echo "✅ Downloaded: quiz.json, quiz.md"
    ;;
  *)
    echo "❌ Unknown artifact type: $ARTIFACT_TYPE"
    exit 1
    ;;
esac

echo "📦 Artifact ready: $OUTPUT_DIR"

#!/bin/bash
# Key Takeaways Extractor
# 从各种产物中提取核心价值摘要

set -euo pipefail

extract_from_report() {
  local file=$1
  
  if [[ ! -f "$file" ]]; then
    echo "• 报告生成中..."
    return
  fi
  
  # 提取标题和主要章节
  local title=$(head -5 "$file" | grep "^# " | head -1 | sed 's/^# //')
  
  # 提取关键要点（前3个H2/H3标题）
  local key_points=$(grep -E "^#{2,3} " "$file" | head -3 | sed 's/^#* //' | sed 's/^/- /')
  
  # 提取总结段落（如果有）
  local summary=""
  if grep -q "## 总结\|## Summary\|## 要点\|## Key Points" "$file"; then
    summary=$(sed -n '/## 总结/,/## /p;/## Summary/,/## /p' "$file" | grep -v "^##" | head -5)
  fi
  
  cat <<EOF
📄 **${title:-学习报告}**

核心要点：
$key_points

${summary:+快速理解：
$summary}
EOF
}

extract_from_mindmap() {
  local file=$1
  
  if [[ ! -f "$file" ]]; then
    echo "• 思维导图生成中..."
    return
  fi
  
  # 解析 JSON 提取核心节点
  local central_topic=$(jq -r '.centralTopic.text // .nodes[0].text // "主题"' "$file" 2>/dev/null)
  local main_branches=$(jq -r '.nodes[1:4].text // empty' "$file" 2>/dev/null | sed 's/^/- /')
  
  cat <<EOF
🗺️ **知识地图：$central_topic**

核心分支：
${main_branches:-• 知识结构清晰呈现}

适合：快速建立整体认知框架
EOF
}

extract_from_quiz() {
  local file=$1
  
  if [[ ! -f "$file" ]]; then
    echo "• 测试题生成中..."
    return
  fi
  
  # 统计题目数量和类型
  local total_questions=$(jq '.questions | length' "$file" 2>/dev/null || echo "0")
  local question_types=$(jq -r '.questions[].type // empty' "$file" 2>/dev/null | sort | uniq -c | sort -rn | head -3)
  local sample_question=$(jq -r '.questions[0].question // empty' "$file" 2>/dev/null | cut -c1-100)
  
  cat <<EOF
❓ **自测练习 ($total_questions 题)**

题型分布：
$(echo "$question_types" | sed 's/^/• /')

示例：
${sample_question}...

💡 建议：先做题再对照报告查漏补缺
EOF
}

extract_from_audio() {
  local file=$1
  local notebook_id=$2
  
  if [[ ! -f "$file" ]]; then
    echo "• 播客生成中..."
    return
  fi
  
  # 获取音频时长
  local duration=""
  if command -v ffprobe &>/dev/null; then
    duration=$(ffprobe -i "$file" -show_entries format=duration -v quiet -of csv="p=0" 2>/dev/null | awk '{printf "%d:%02d", $1/60, $1%60}')
  fi
  
  cat <<EOF
🎙️ **深度播客 ${duration:+($duration)}**

本期内容：
• 两位AI主持人的深度对话
• 从多个角度解析核心概念
• 结合实际案例讲解

🎧 适合场景：通勤、运动、休息时收听
🔗 NotebookLM 可查看完整对话文本
EOF
}

extract_from_slides() {
  local file=$1
  
  if [[ ! -f "$file" ]]; then
    echo "• PPT生成中..."
    return
  fi
  
  local size=$(du -h "$file" 2>/dev/null | cut -f1)
  
  cat <<EOF
📊 **PPT讲义 (${size})**

内容特点：
• 结构化知识点呈现
• 图文结合易于理解
• 可直接用于分享或演讲

💼 适用：团队分享、学习笔记、演讲素材
EOF
}

extract_from_video() {
  local file=$1
  
  if [[ ! -f "$file" ]]; then
    echo "• 视频生成中..."
    return
  fi
  
  local size=$(du -h "$file" 2>/dev/null | cut -f1)
  
  cat <<EOF
🎬 **视频解说 (${size})**

视频特点：
• 带旁白的幻灯片演示
• 视觉+听觉双重学习
• 节奏适中便于理解

📺 适合：喜欢视频学习的用户
EOF
}

# 主函数
main() {
  local artifact_type=$1
  local artifact_file=$2
  local notebook_id=${3:-}
  
  case $artifact_type in
    report)
      extract_from_report "$artifact_file"
      ;;
    mindmap)
      extract_from_mindmap "$artifact_file"
      ;;
    quiz)
      extract_from_quiz "$artifact_file"
      ;;
    audio|podcast)
      extract_from_audio "$artifact_file" "$notebook_id"
      ;;
    slides|ppt)
      extract_from_slides "$artifact_file"
      ;;
    video)
      extract_from_video "$artifact_file"
      ;;
    *)
      echo "• 产物已就绪，点击查看详情"
      ;;
  esac
}

# 如果直接运行
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  if [[ $# -lt 2 ]]; then
    echo "Usage: $0 <artifact_type> <artifact_file> [notebook_id]"
    echo "Types: report, mindmap, quiz, audio, slides, video"
    exit 1
  fi
  main "$@"
fi

#!/bin/bash
# Generate all NotebookLM artifacts in parallel (Enhanced Version)
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Load configuration
source "$SCRIPT_DIR/config_loader.sh" 2>/dev/null || true
load_config

NOTEBOOK_ID=""
OUTPUT_DIR=""
ARTIFACTS_TO_GENERATE="${ARTIFACTS_TO_GENERATE:-report audio slides mindmap quiz}"
ENABLE_VIDEO="${ENABLE_VIDEO:-true}"
ENABLE_INFOGRAPHIC="${ENABLE_INFOGRAPHIC:-false}"
ENABLE_FLASHCARDS="${ENABLE_FLASHCARDS:-true}"

while [[ $# -gt 0 ]]; do
  case $1 in
    --notebook) NOTEBOOK_ID="$2"; shift 2 ;;
    --output) OUTPUT_DIR="$2"; shift 2 ;;
    --artifacts) ARTIFACTS_TO_GENERATE="$2"; shift 2 ;;
    --enable-video) ENABLE_VIDEO="$2"; shift 2 ;;
    --enable-infographic) ENABLE_INFOGRAPHIC="$2"; shift 2 ;;
    --enable-flashcards) ENABLE_FLASHCARDS="$2"; shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$NOTEBOOK_ID" ]] && { echo "Error: --notebook required"; exit 1; }
[[ -z "$OUTPUT_DIR" ]] && { echo "Error: --output required"; exit 1; }

echo "🎨 Starting artifact generation..."
echo "   Notebook: $NOTEBOOK_ID"
echo "   Artifacts: $ARTIFACTS_TO_GENERATE"

# Initialize artifact IDs
REPORT_ID=""
AUDIO_ID=""
SLIDE_ID=""
MINDMAP_ID=""
QUIZ_ID=""
VIDEO_ID=""
INFOGRAPHIC_ID=""
FLASHCARDS_ID=""

# Generate requested artifacts
if [[ "$ARTIFACTS_TO_GENERATE" == *"report"* ]]; then
  echo "  📄 Report..."
  REPORT_JSON=$(notebooklm generate report --format study-guide -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  REPORT_ID=$(echo "$REPORT_JSON" | jq -r '.task_id // .id // empty')
fi

if [[ "$ARTIFACTS_TO_GENERATE" == *"audio"* ]]; then
  echo "  🎙️ Podcast..."
  AUDIO_JSON=$(notebooklm generate audio --format deep-dive -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  AUDIO_ID=$(echo "$AUDIO_JSON" | jq -r '.task_id // .id // empty')
fi

if [[ "$ARTIFACTS_TO_GENERATE" == *"slides"* ]]; then
  echo "  📊 Slides..."
  SLIDE_JSON=$(notebooklm generate slide-deck --format detailed -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  SLIDE_ID=$(echo "$SLIDE_JSON" | jq -r '.task_id // .id // empty')
fi

if [[ "$ARTIFACTS_TO_GENERATE" == *"mindmap"* ]]; then
  echo "  🗺️ Mind map..."
  MAP_JSON=$(notebooklm generate mind-map -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  MINDMAP_ID=$(echo "$MAP_JSON" | jq -r '.task_id // .id // empty')
fi

if [[ "$ARTIFACTS_TO_GENERATE" == *"quiz"* ]]; then
  echo "  ❓ Quiz..."
  QUIZ_JSON=$(notebooklm generate quiz --difficulty medium -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  QUIZ_ID=$(echo "$QUIZ_JSON" | jq -r '.task_id // .id // empty')
fi

if [[ "$ENABLE_VIDEO" == "true" && "$ARTIFACTS_TO_GENERATE" == *"video"* ]]; then
  echo "  🎬 Video Brief..."
  VIDEO_JSON=$(notebooklm generate video -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  VIDEO_ID=$(echo "$VIDEO_JSON" | jq -r '.task_id // .id // empty')
  [[ -n "$VIDEO_ID" && "$VIDEO_ID" != "null" ]] && echo "  ✅ Video generation started"
fi

if [[ "$ENABLE_INFOGRAPHIC" == "true" && "$ARTIFACTS_TO_GENERATE" == *"infographic"* ]]; then
  echo "  📊 Infographic..."
  INFOGRAPHIC_JSON=$(notebooklm generate infographic -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  INFOGRAPHIC_ID=$(echo "$INFOGRAPHIC_JSON" | jq -r '.task_id // .id // empty')
  [[ -n "$INFOGRAPHIC_ID" && "$INFOGRAPHIC_ID" != "null" ]] && echo "  ✅ Infographic generation started"
fi

if [[ "$ENABLE_FLASHCARDS" == "true" && "$ARTIFACTS_TO_GENERATE" == *"flashcards"* ]]; then
  echo "  🃏 Flashcards..."
  FLASHCARDS_JSON=$(notebooklm generate flashcards -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
  FLASHCARDS_ID=$(echo "$FLASHCARDS_JSON" | jq -r '.task_id // .id // empty')
  [[ -n "$FLASHCARDS_ID" && "$FLASHCARDS_ID" != "null" ]] && echo "  ✅ Flashcards generation started"
fi

# Save artifact IDs
cat > "$OUTPUT_DIR/artifacts.json" <<EOF
{
  "report": "$REPORT_ID",
  "audio": "$AUDIO_ID",
  "slides": "$SLIDE_ID",
  "mindmap": "$MINDMAP_ID",
  "quiz": "$QUIZ_ID",
  "video": "$VIDEO_ID",
  "infographic": "$INFOGRAPHIC_ID",
  "flashcards": "$FLASHCARDS_ID"
}
EOF

echo "✅ Generation started. Artifact IDs saved to artifacts.json"
echo "⏳ Use subagents to wait and download each artifact"

#!/bin/bash
# Deep Learning Orchestrator - Enhanced Version
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SKILL_DIR="$(dirname "$SCRIPT_DIR")"
OUTPUT_BASE="$HOME/.openclaw/workspace/deep-learning-output"

# Load configuration
source "$SCRIPT_DIR/config_loader.sh"
load_config

# Parse arguments
TOPIC=""
MATERIALS=()
MODE="full"  # full|collect-only|generate-only
RESEARCH_MODE="${DEFAULT_RESEARCH_MODE:-deep}"
ARTIFACTS="${DEFAULT_ARTIFACTS:-report audio slides mindmap quiz}"
PROMPT_CATEGORY=""
DELIVERY_MODE="${DEFAULT_DELIVERY_MODE:-progressive}"  # progressive|batch

while [[ $# -gt 0 ]]; do
  case $1 in
    --topic) TOPIC="$2"; shift 2 ;;
    --material|--materials) MATERIALS+=("$2"); shift 2 ;;
    --mode) MODE="$2"; shift 2 ;;
    --research-mode) RESEARCH_MODE="$2"; shift 2 ;;
    --artifacts) ARTIFACTS="$2"; shift 2 ;;
    --prompt-category) PROMPT_CATEGORY="$2"; shift 2 ;;
    --delivery-mode) DELIVERY_MODE="$2"; shift 2 ;;
    *) echo "Unknown option: $1"; exit 1 ;;
  esac
done

if [[ -z "$TOPIC" ]]; then
  echo "Error: --topic required"
  exit 1
fi

echo "🚀 Starting enhanced deep learning workflow: $TOPIC"
echo "📦 Materials: ${#MATERIALS[@]}"
echo "🔧 Mode: $MODE"
echo "🔬 Research Mode: $RESEARCH_MODE"
echo "🎨 Artifacts: $ARTIFACTS"
echo ""

# Create notebook
echo "📚 Creating NotebookLM notebook..."
NOTEBOOK_JSON=$(notebooklm create "深度学习：$TOPIC" --json)
NOTEBOOK_ID=$(echo "$NOTEBOOK_JSON" | jq -r '.notebook.id')

if [[ -z "$NOTEBOOK_ID" || "$NOTEBOOK_ID" == "null" ]]; then
  echo "❌ Failed to create notebook"
  exit 1
fi

echo "✅ Notebook created: $NOTEBOOK_ID"
echo "🔗 https://notebooklm.google.com/notebook/$NOTEBOOK_ID"
echo ""

# Create output directory
OUTPUT_DIR="$OUTPUT_BASE/$NOTEBOOK_ID"
mkdir -p "$OUTPUT_DIR"

# Save metadata
cat > "$OUTPUT_DIR/metadata.json" <<EOF
{
  "topic": "$TOPIC",
  "notebook_id": "$NOTEBOOK_ID",
  "created_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
  "materials_count": ${#MATERIALS[@]},
  "research_mode": "$RESEARCH_MODE",
  "artifacts": "$ARTIFACTS"
}
EOF

# Phase 1: Collect materials
if [[ "$MODE" == "full" || "$MODE" == "collect-only" ]]; then
  echo "📥 Collecting materials..."
  SOURCE_IDS=()
  
  # Check if no materials provided (Deep Research mode)
  if [[ ${#MATERIALS[@]} -eq 0 ]]; then
    echo "  🔬 No materials provided, activating research mode: $RESEARCH_MODE"
    echo "  🔍 Searching for sources on: $TOPIC"
    
    if [[ "$RESEARCH_MODE" == "fast" ]]; then
      # Fast Research: 10-20 seconds
      echo "  ⚡ Fast Research mode (10-20 seconds)"
      notebooklm source add-research "$TOPIC" -n "$NOTEBOOK_ID" --mode fast --no-wait 2>&1 | tee -a "$OUTPUT_DIR/research.log"
      echo "  ⏳ Waiting for fast research to complete..."
      notebooklm research wait -n "$NOTEBOOK_ID" --import-all --timeout 60 2>&1 | tee -a "$OUTPUT_DIR/research.log"
    else
      # Deep Research: 2-30 minutes
      echo "  🧠 Deep Research mode (2-30 minutes)"
      notebooklm source add-research "$TOPIC" -n "$NOTEBOOK_ID" --mode deep --no-wait 2>&1 | tee -a "$OUTPUT_DIR/research.log"
      echo "  ⏳ Waiting for deep research to complete (this may take a while)..."
      notebooklm research wait -n "$NOTEBOOK_ID" --import-all --timeout 1800 2>&1 | tee -a "$OUTPUT_DIR/research.log"
    fi
    
    echo "  ✅ Research completed"
    echo "0" > "$OUTPUT_DIR/source_ids.txt"
  else
    # Process provided materials
    for material in "${MATERIALS[@]}"; do
      echo "  Processing: $material"
      
      # Detect if material needs preprocessing with jina-reader
      NEEDS_JINA=false
      if [[ "$material" =~ ^https?://(x\.com|twitter\.com|reddit\.com|medium\.com|linkedin\.com)/ ]]; then
        NEEDS_JINA=true
        echo "  🔄 Social media link detected, using jina-reader..."
      fi
      
      if [[ "$NEEDS_JINA" == "true" ]]; then
        # Use jina-reader to extract content
        MARKDOWN=$(curl -s "https://r.jina.ai/$material" || echo "")
        if [[ -n "$MARKDOWN" ]]; then
          TITLE=$(echo "$MARKDOWN" | head -1 | sed 's/^# //')
          # Add as text source
          SOURCE_JSON=$(notebooklm source add "$MARKDOWN" --type text --title "$TITLE" -n "$NOTEBOOK_ID" --json 2>&1 || echo '{"error": true}')
        else
          echo "  ⚠️  jina-reader failed, trying direct add..."
          SOURCE_JSON=$(notebooklm source add "$material" --json -n "$NOTEBOOK_ID" 2>&1 || echo '{"error": true}')
        fi
      else
        # Add directly
        SOURCE_JSON=$(notebooklm source add "$material" --json -n "$NOTEBOOK_ID" 2>&1 || echo '{"error": true}')
      fi
      
      if echo "$SOURCE_JSON" | jq -e '.error' > /dev/null 2>&1; then
        echo "  ⚠️  Failed to add source, continuing..."
        continue
      fi
      
      SOURCE_ID=$(echo "$SOURCE_JSON" | jq -r '.source.id // .id')
      if [[ -n "$SOURCE_ID" && "$SOURCE_ID" != "null" ]]; then
        SOURCE_IDS+=("$SOURCE_ID")
        echo "  ✅ Added: $SOURCE_ID"
      fi
    done
  fi
  
  echo ""
  echo "✅ Collected ${#SOURCE_IDS[@]} sources"
  
  if [[ ${#SOURCE_IDS[@]} -eq 0 ]]; then
    echo "❌ No sources collected, exiting"
    exit 1
  fi
  
  echo "${SOURCE_IDS[@]}" > "$OUTPUT_DIR/source_ids.txt"
fi

# Phase 2: Generate artifacts
if [[ "$MODE" == "full" || "$MODE" == "generate-only" ]]; then
  echo ""
  echo "🎨 Generating artifacts..."
  
  bash "$SCRIPT_DIR/generate_artifacts.sh" \
    --notebook "$NOTEBOOK_ID" \
    --output "$OUTPUT_DIR" \
    --artifacts "$ARTIFACTS" \
    --enable-video "${ENABLE_VIDEO:-true}" \
    --enable-infographic "${ENABLE_INFOGRAPHIC:-false}" \
    --enable-flashcards "${ENABLE_FLASHCARDS:-true}"
  
  # Wait and download artifacts
  echo ""
  echo "⏳ Waiting for artifacts to complete..."
  
  cd "$OUTPUT_DIR"
  
  # Load artifact IDs
  [[ -f artifacts.json ]] || { echo "❌ artifacts.json not found"; exit 1; }
  
  REPORT_ID=$(jq -r '.report // empty' artifacts.json)
  AUDIO_ID=$(jq -r '.audio // empty' artifacts.json)
  SLIDES_ID=$(jq -r '.slides // empty' artifacts.json)
  QUIZ_ID=$(jq -r '.quiz // empty' artifacts.json)
  VIDEO_ID=$(jq -r '.video // empty' artifacts.json)
  INFOGRAPHIC_ID=$(jq -r '.infographic // empty' artifacts.json)
  FLASHCARDS_ID=$(jq -r '.flashcards // empty' artifacts.json)
  
  # Wait up to 10 minutes for artifacts
  for i in {1..60}; do
    sleep 10
    COMPLETED=0
    TOTAL=0
    
    [[ -n "$REPORT_ID" && "$REPORT_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$AUDIO_ID" && "$AUDIO_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$SLIDES_ID" && "$SLIDES_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$QUIZ_ID" && "$QUIZ_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$VIDEO_ID" && "$VIDEO_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$INFOGRAPHIC_ID" && "$INFOGRAPHIC_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    [[ -n "$FLASHCARDS_ID" && "$FLASHCARDS_ID" != "null" ]] && TOTAL=$((TOTAL+1))
    
    # Try downloading
    [[ -n "$REPORT_ID" ]] && notebooklm download report ./report.md -a "$REPORT_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$AUDIO_ID" ]] && notebooklm download audio ./podcast.mp3 -a "$AUDIO_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$SLIDES_ID" ]] && notebooklm download slide-deck ./slides.pdf -a "$SLIDES_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$QUIZ_ID" ]] && notebooklm download quiz ./quiz.json -a "$QUIZ_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$VIDEO_ID" ]] && notebooklm download video ./video.mp4 -a "$VIDEO_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$INFOGRAPHIC_ID" ]] && notebooklm download infographic ./infographic.png -a "$INFOGRAPHIC_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    [[ -n "$FLASHCARDS_ID" ]] && notebooklm download flashcards ./flashcards.json -a "$FLASHCARDS_ID" -n "$NOTEBOOK_ID" 2>/dev/null && COMPLETED=$((COMPLETED+1))
    
    [[ $COMPLETED -gt 0 ]] && echo "  Progress: $COMPLETED/$TOTAL artifacts ready"
    [[ $COMPLETED -eq $TOTAL && $TOTAL -gt 0 ]] && break
  done
  
  echo "  ✅ Downloaded $COMPLETED/$TOTAL artifacts"
fi

echo ""
echo "✅ Workflow complete!"
echo "📂 Output: $OUTPUT_DIR"

# Phase 3: Save to Obsidian & Send summary to Feishu
if [[ "$ENABLE_OBSIDIAN_INTEGRATION" == "true" ]]; then
  if [[ -f "$OUTPUT_DIR/report.md" ]] || [[ -f "$OUTPUT_DIR/slides.pdf" ]]; then
    echo ""
    echo "💾 Saving to Obsidian Inbox..."
    
    OBSIDIAN_INBOX="${OBSIDIAN_INBOX_PATH:-$HOME/Library/CloudStorage/OneDrive-个人/obsidian-vault/Inbox}"
    mkdir -p "$OBSIDIAN_INBOX"
    
    TIMESTAMP=$(date +"%Y-%m-%d")
    SAFE_TOPIC=$(echo "$TOPIC" | tr ' ' '-' | tr -cd '[:alnum:]-')
    INBOX_FILE="$OBSIDIAN_INBOX/${TIMESTAMP}__notebooklm__${SAFE_TOPIC}.md"
    
    # Create inbox entry
    cat > "$INBOX_FILE" <<EOF
# $TOPIC

> 学习时间：$TIMESTAMP
> NotebookLM：https://notebooklm.google.com/notebook/$NOTEBOOK_ID
> Research Mode: $RESEARCH_MODE

## 学习材料

EOF
    
    # Append report content
    [[ -f "$OUTPUT_DIR/report.md" ]] && cat "$OUTPUT_DIR/report.md" >> "$INBOX_FILE"
    
    # Copy attachments
    [[ -f "$OUTPUT_DIR/slides.pdf" ]] && cp "$OUTPUT_DIR/slides.pdf" "$OBSIDIAN_INBOX/"
    [[ -f "$OUTPUT_DIR/podcast.mp3" ]] && cp "$OUTPUT_DIR/podcast.mp3" "$OBSIDIAN_INBOX/"
    [[ -f "$OUTPUT_DIR/quiz.json" ]] && cp "$OUTPUT_DIR/quiz.json" "$OBSIDIAN_INBOX/"
    [[ -f "$OUTPUT_DIR/video.mp4" ]] && cp "$OUTPUT_DIR/video.mp4" "$OBSIDIAN_INBOX/"
    [[ -f "$OUTPUT_DIR/infographic.png" ]] && cp "$OUTPUT_DIR/infographic.png" "$OBSIDIAN_INBOX/"
    
    echo "  ✅ Saved to: $INBOX_FILE"
  fi
fi

# Send summary to Feishu
echo ""
echo "📤 Sending summary to Feishu..."

SUMMARY="📚 深度学习完成：$TOPIC

✅ 已保存到 Obsidian Inbox
📂 Research Mode: $RESEARCH_MODE

产物：
$([ -f "$OUTPUT_DIR/report.md" ] && echo "📄 学习报告")
$([ -f "$OUTPUT_DIR/slides.pdf" ] && echo "📊 PPT 讲义")
$([ -f "$OUTPUT_DIR/podcast.mp3" ] && echo "🎙️ 音频播客")
$([ -f "$OUTPUT_DIR/quiz.json" ] && echo "❓ 测试题")
$([ -f "$OUTPUT_DIR/video.mp4" ] && echo "🎬 视频解说")
$([ -f "$OUTPUT_DIR/infographic.png" ] && echo "📊 信息图")
$([ -f "$OUTPUT_DIR/flashcards.json" ] && echo "🃏 闪卡")

🔗 NotebookLM: https://notebooklm.google.com/notebook/$NOTEBOOK_ID"

message action=send channel=feishu target=current message="$SUMMARY" 2>/dev/null || echo "  ⚠️  Failed to send to Feishu"
echo "  ✅ Summary sent"

#!/bin/bash
# Progressive Delivery Orchestrator
# 实现产物逐步交付，不等待全部完成

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SKILL_DIR="$(dirname "$SCRIPT_DIR")"
OUTPUT_BASE="$HOME/.openclaw/workspace/deep-learning-output"

# 加载配置
source "$SKILL_DIR/scripts/config_loader.sh" 2>/dev/null || true
load_config

NOTEBOOK_ID=""
TOPIC=""
OUTPUT_DIR=""
FEISHU_TARGET="current"

# 解析参数
while [[ $# -gt 0 ]]; do
  case $1 in
    --notebook) NOTEBOOK_ID="$2"; shift 2 ;;
    --topic) TOPIC="$2"; shift 2 ;;
    --output) OUTPUT_DIR="$2"; shift 2 ;;
    --feishu-target) FEISHU_TARGET="$2"; shift 2 ;;
    *) echo "Unknown: $1"; exit 1 ;;
  esac
done

[[ -z "$NOTEBOOK_ID" ]] && { echo "Error: --notebook required"; exit 1; }
[[ -z "$TOPIC" ]] && { echo "Error: --topic required"; exit 1; }
[[ -z "$OUTPUT_DIR" ]] && { echo "Error: --output required"; exit 1; }

echo "🚀 Starting progressive delivery for: $TOPIC"
echo "   Notebook: $NOTEBOOK_ID"
echo ""

# 产物优先级队列（按交付速度排序）
ARTIFACT_QUEUE=(
  "mindmap:instant:🗺️ 思维导图"
  "report:fast:📄 学习报告"
  "quiz:medium:❓ 测试题"
  "audio:slow:🎙️ 深度播客"
  "slides:slow:📊 PPT讲义"
  "video:slow:🎬 视频解说"
)

# 跟踪已交付产物
declare -A DELIVERED
declare -A ARTIFACT_IDS

# 生成并等待单个产物
generate_and_wait() {
  local artifact_type=$1
  local timeout=$2
  
  echo "  🎨 Generating $artifact_type..."
  
  local generate_json
  case $artifact_type in
    mindmap)
      generate_json=$(notebooklm generate mind-map -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
    report)
      generate_json=$(notebooklm generate report --format study-guide -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
    quiz)
      generate_json=$(notebooklm generate quiz --difficulty medium -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
    audio)
      generate_json=$(notebooklm generate audio --format deep-dive -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
    slides)
      generate_json=$(notebooklm generate slide-deck --format detailed -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
    video)
      generate_json=$(notebooklm generate video -n "$NOTEBOOK_ID" --json 2>&1 || echo '{}')
      ;;
  esac
  
  local artifact_id=$(echo "$generate_json" | jq -r '.task_id // .id // empty')
  [[ -z "$artifact_id" ]] && return 1
  
  ARTIFACT_IDS[$artifact_type]=$artifact_id
  
  # 等待完成
  local waited=0
  local interval=10
  local max_wait=$timeout
  
  while [[ $waited -lt $max_wait ]]; do
    sleep $interval
    waited=$((waited + interval))
    
    # 尝试下载
    local download_result=1
    cd "$OUTPUT_DIR"
    
    case $artifact_type in
      mindmap)
        notebooklm download mind-map ./mindmap.json -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
      report)
        notebooklm download report ./report.md -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
      quiz)
        notebooklm download quiz ./quiz.json -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
      audio)
        notebooklm download audio ./podcast.mp3 -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
      slides)
        notebooklm download slide-deck ./slides.pdf -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
      video)
        notebooklm download video ./video.mp4 -a "$artifact_id" -n "$NOTEBOOK_ID" 2>/dev/null && download_result=0
        ;;
    esac
    
    if [[ $download_result -eq 0 ]]; then
      echo "  ✅ $artifact_type ready (${waited}s)"
      return 0
    fi
  done
  
  echo "  ⚠️  $artifact_type timeout after ${max_wait}s"
  return 1
}

# 提取 Key Takeaways
extract_key_takeaways() {
  local artifact_file=$1
  local artifact_type=$2
  
  case $artifact_type in
    report)
      # 从报告中提取前3个要点
      if [[ -f "$artifact_file" ]]; then
        head -50 "$artifact_file" | grep -E "^#{1,3} " | head -3 | sed 's/^#* //' | while read line; do
          echo "• $line"
        done
      fi
      ;;
    mindmap)
      # 提取思维导图核心节点
      if [[ -f "$artifact_file" ]]; then
        jq -r '.nodes[0:3].text // empty' "$artifact_file" 2>/dev/null | while read line; do
          [[ -n "$line" ]] && echo "• $line"
        done
      fi
      ;;
    quiz)
      # 提取测试题主题
      if [[ -f "$artifact_file" ]]; then
        jq -r '.questions[0].question // empty' "$artifact_file" 2>/dev/null | head -1
      fi
      ;;
    *)
      echo "• 新鲜出炉，立即查看！"
      ;;
  esac
}

# 发送渐进交付通知
send_progressive_notification() {
  local artifact_type=$1
  local emoji=$2
  local artifact_file=$3
  
  # 提取关键信息
  local takeaways=$(extract_key_takeaways "$artifact_file" "$artifact_type")
  local file_size=""
  [[ -f "$artifact_file" ]] && file_size=$(du -h "$artifact_file" | cut -f1)
  
  # 构建消息
  local message="${emoji} ${TOPIC} - 新产物就绪！

Key Takeaways:
${takeaways:-• 新鲜出炉，立即查看！}

文件：$(basename "$artifact_file") (${file_size})
NotebookLM：https://notebooklm.google.com/notebook/$NOTEBOOK_ID

---
⏳ 更多产物生成中，完成后会继续通知..."

  # 发送到 Feishu
  message action=send channel=feishu target="$FEISHU_TARGET" message="$message" 2>/dev/null || echo "  ⚠️ Failed to send notification"
}

# 主流程
echo "📦 Progressive Delivery Queue:"
printf '%s\n' "${ARTIFACT_QUEUE[@]}" | while IFS=: read type speed label; do
  echo "   $label ($speed)"
done
echo ""

# 启动所有产物生成（后台并行）
echo "🎨 Starting all artifact generation in parallel..."
for item in "${ARTIFACT_QUEUE[@]}"; do
  IFS=: read type speed label <<< "$item"
  
  # 根据类型设置超时
  case $speed in
    instant) timeout=60 ;;
    fast) timeout=300 ;;
    medium) timeout=600 ;;
    slow) timeout=1800 ;;
    *) timeout=300 ;;
  esac
  
  # 后台生成
  (
    if generate_and_wait "$type" "$timeout"; then
      DELIVERED[$type]=true
      
      # 确定文件路径
      case $type in
        mindmap) file="$OUTPUT_DIR/mindmap.json" ;;
        report) file="$OUTPUT_DIR/report.md" ;;
        quiz) file="$OUTPUT_DIR/quiz.json" ;;
        audio) file="$OUTPUT_DIR/podcast.mp3" ;;
        slides) file="$OUTPUT_DIR/slides.pdf" ;;
        video) file="$OUTPUT_DIR/video.mp4" ;;
      esac
      
      # 发送通知
      send_progressive_notification "$type" "$label" "$file"
    else
      DELIVERED[$type]=false
      echo "  ❌ $type failed"
    fi
  ) &
done

# 等待所有后台任务完成
wait

# 生成最终总结
echo ""
echo "✅ Progressive delivery complete!"
echo ""
echo "📊 Delivery Summary:"
for item in "${ARTIFACT_QUEUE[@]}"; do
  IFS=: read type speed label <<< "$item"
  status="${DELIVERED[$type]:-false}"
  if [[ "$status" == "true" ]]; then
    echo "   ✅ $label"
  else
    echo "   ❌ $label (failed)"
  fi
done

# 保存交付记录
cat > "$OUTPUT_DIR/progressive_delivery.json" <<EOF
{
  "topic": "$TOPIC",
  "notebook_id": "$NOTEBOOK_ID",
  "completed_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
  "artifacts": {
    "mindmap": ${DELIVERED[mindmap]:-false},
    "report": ${DELIVERED[report]:-false},
    "quiz": ${DELIVERED[quiz]:-false},
    "audio": ${DELIVERED[audio]:-false},
    "slides": ${DELIVERED[slides]:-false},
    "video": ${DELIVERED[video]:-false}
  }
}
EOF