docs(drive): document 30-char query limit for +search (#1560)

The Search v2 API rejects queries longer than 30 characters (counted by
Unicode code point, CJK 1 each) with 99992402 field validation failed —
it is a hard error, not truncation. Surface this in the --query -h help
text and the lark-drive search skill so callers compress long queries
before searching instead of hitting the error.

Change-Id: Ieb30a66edae7a573690c49719627ec8fb2500a1a

CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file.
 
+## [v1.0.64] - 2026-07-02
+
+### Features
+
+- **im**: Upgrade card send to Card 2.0 with full component reference (#1688)
+- **im**: Add `+chat-members-list` shortcut for member listing (#1398)
+- **okr**: Semi-plain text format with mention position preservation and `patch` shortcut (#1671)
+
+### Bug Fixes
+
+- **cli**: Point permission-apply link at official `/page/scope-apply` entry (#1722)
+- **cli**: Improve secure label error handling (#1707)
+- **cli**: Reduce public content token false positives
+- **cli**: Increase npm registry fetch timeout to 15s during update check (#1724)
+- **doc**: Align word statistics compound tokens (#1706)
+
+### Documentation
+
+- **approval**: Add detailed command-to-reference mapping for the approval skill (#1630)
+- **doc**: Support `reference_map` in docs (#1690)
+- **slides**: Refresh generation guidance — add constraints, drop template toolchain, and inline lint XML fixtures
+
 ## [v1.0.62] - 2026-07-01
 
 ### Features
@@ -1333,6 +1355,7 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
+[v1.0.64]: https://github.com/larksuite/cli/releases/tag/v1.0.64
 [v1.0.62]: https://github.com/larksuite/cli/releases/tag/v1.0.62
 [v1.0.61]: https://github.com/larksuite/cli/releases/tag/v1.0.61
 [v1.0.60]: https://github.com/larksuite/cli/releases/tag/v1.0.60

docs/superpowers/specs/2026-07-02-create-svglide-codex-runtime-design.md

@@ -1,259 +0,0 @@
-# `slides +create-svglide` Codex Runtime Design
-
-Date: 2026-07-02
-Branch: `feat-svglide-07`
-Scope: first local-only version of `lark-cli slides +create-svglide`
-
-## Result
-
-Build `slides +create-svglide` as a staged local runtime for AnyGen SVG Slides. The command creates and manages a run directory that Codex can fill with generated content, assets, and SVG slides. The CLI owns state, prompts, schemas, validation, preview, receipts, and recovery. Codex owns LLM reasoning, web research, image/search execution, chart design, and SVG authoring.
-
-The first version does not publish to Feishu Slides. It must produce a local, inspectable SVG deck workbench.
-
-## Context
-
-`feat-svglide-07` currently starts from the latest `origin/main` and has only the existing Slides XML shortcut surface. There is no current `+create-svglide` implementation on this branch.
-
-The AnyGen SVG Slides prompt should be reused as contracts and workflow rules, not pasted as one large prompt. Its value is split across request interpretation, research, design brief, outline, `slide_content.md`, asset planning, SVG authoring, protocol validation, preview, and repair.
-
-## Goals
-
-- Add a staged `slides +create-svglide` command group.
-- Create a local run directory under a user-specified `--out` path, usually `.lark-slides/svglide-runs/<run-id>`.
-- Generate prompt task files that tell Codex exactly what to produce for each stage.
-- Generate JSON schemas for stage outputs.
-- Track stage state in `run.json`.
-- Validate JSON outputs, SVG protocol basics, asset href existence, slide count, placeholder slides, and preview generation.
-- Generate `preview.html` for local inspection.
-- Write receipts and `repair_queue.md` so failed runs can resume from the current stage.
-
-## Non-Goals
-
-- No online Feishu Slides creation.
-- No `slide_engine` or `slide` server changes.
-- No SVG-to-SXSD conversion.
-- No built-in model API provider.
-- No built-in web search, image generation, or image search client.
-- No complete 12-agent process runner.
-- No PPTX import/edit workflow.
-
-## Command Surface
-
-```bash
-lark-cli slides +create-svglide init --title "Demo" --input ./source.md --audience "..." --delivery-mode self_read --pages 8 --out ./.lark-slides/svglide-runs/demo
-lark-cli slides +create-svglide next <run-dir>
-lark-cli slides +create-svglide status <run-dir>
-lark-cli slides +create-svglide validate <run-dir>
-lark-cli slides +create-svglide preview <run-dir>
-```
-
-`init` creates the run directory, writes the initial request files, schemas, stage prompts, and `run.json`.
-
-`next` reads `run.json`, finds the next stage, verifies required inputs, renders or refreshes that stage's Codex task prompt, and reports the exact files Codex must create. It must not pretend LLM work is complete.
-
-`status` checks declared outputs and receipts for each stage, then prints the current stage, missing files, and next useful command.
-
-`validate` runs deterministic checks and writes validation receipts.
-
-`preview` writes `preview.html` from `outline/deck.json` and `slides/*.svg`.
-
-## Run Directory Contract
-
-```text
-<run-dir>/
-  run.json
-  README.md
-  request/request.json
-  request/source_manifest.json
-  research/research_notes.md
-  research/sources.json
-  brief/design_brief.json
-  brief/visual_system.json
-  outline/deck.json
-  content/slide_content.md
-  content/slide_content.json
-  assets/assets_plan.json
-  assets/images/
-  assets/charts/
-  slides/*.svg
-  prompts/*.task.md
-  schemas/*.schema.json
-  receipts/*.json
-  receipts/generation_summary.md
-  repair_queue.md
-  preview.html
-```
-
-The run directory is local agent state. It should not be committed by default.
-
-## State Model
-
-`run.json` stores:
-
-- version
-- runtime, always `codex` in v1
-- command name
-- title
-- created and updated timestamps
-- current stage
-- stage list with status, inputs, outputs, and receipt path
-- important artifact paths
-- policy flags: `publish_enabled=false`, `network_by_codex=true`, `image_generation_by_codex=true`, `overwrite=false`
-
-Stage statuses:
-
-```text
-pending
-ready
-in_progress
-done
-failed
-blocked
-needs_repair
-```
-
-## Stage Design
-
-### 1. request
-
-Role: Request Interpreter
-
-Input: CLI flags and local source path.
-
-Output: `request/request.json`, `request/source_manifest.json`.
-
-Validation: title, audience, delivery mode, page count, and source references must be explicit or marked missing.
-
-### 2. research
-
-Role: Researcher
-
-Input: request files and source files.
-
-Output: `research/research_notes.md`, `research/sources.json`.
-
-Validation: key facts need source references. Codex may perform web research, but the CLI only validates resulting files.
-
-### 3. design_brief
-
-Role: Design Brief Resolver and Visual System Planner
-
-Input: request and research outputs.
-
-Output: `brief/design_brief.json`, `brief/visual_system.json`.
-
-Validation: narrative spine, depth, tone, and visual system dimensions must be present.
-
-### 4. outline
-
-Role: Outline Planner
-
-Input: design brief.
-
-Output: `outline/deck.json`.
-
-Validation: page count matches request; each slide has id, title, summary, role, and key message.
-
-### 5. slide_content
-
-Role: Content Builder
-
-Input: deck outline and research notes.
-
-Output: `content/slide_content.md`, `content/slide_content.json`.
-
-Validation: every slide has key material, content blocks, and source notes. This is content planning, not final layout.
-
-### 6. assets
-
-Role: Asset Planner and Chart Generator
-
-Input: slide content and visual system.
-
-Output: `assets/assets_plan.json`, optional `assets/images/*`, optional `assets/charts/*.svg`.
-
-Validation: every planned asset has purpose plus either a local path or a fallback. Chart takeaway must be written before chart type.
-
-### 7. svg_author
-
-Role: SVG Author
-
-Input: deck, slide content, visual system, and assets.
-
-Output: `slides/*.svg`.
-
-Validation: each slide must contain more than a background. Each slide needs a background, title, visible content or visual element, semantic id, and valid SVG root.
-
-### 8. validate_preview_repair
-
-Role: Protocol Validator, Preview Agent, and Repair Agent
-
-Input: generated slides.
-
-Output: `receipts/lint.json`, `receipts/preview.json`, `repair_queue.md`, `preview.html`.
-
-Validation: SVG protocol lint, local href checks, slide count match, preview write success, and unresolved issues recorded in the repair queue.
-
-## Code Layout
-
-```text
-shortcuts/slides/
-  slides_create_svglide.go
-  slides_create_svglide_test.go
-
-internal/svglide/
-  run.go
-  init.go
-  stage.go
-  prompt.go
-  schema.go
-  validate.go
-  preview.go
-  receipt.go
-```
-
-The shortcut package should stay thin. State, prompt rendering, validation, and preview logic belong in `internal/svglide` so they can be tested without a Cobra/runtime-heavy command harness.
-
-## Skill Documentation
-
-Update `skills/lark-slides/SKILL.md` and add a focused reference file for the local SVG runtime. The skill should explain that `+create-svglide` is local-only in v1, requires Codex to fill stage outputs, and must not be described as an online publish path.
-
-## Error Handling
-
-- Missing required inputs block the stage and write a receipt.
-- Invalid JSON or schema mismatch marks the stage failed.
-- Invalid SVG marks `needs_repair` and writes `repair_queue.md`.
-- Existing output paths are not overwritten unless an explicit overwrite policy is enabled.
-- Partially completed stages remain inspectable; reruns resume from the current stage.
-
-## Tests
-
-Unit tests:
-
-- `init` creates the expected directory tree and `run.json`.
-- `init` refuses to overwrite an existing run directory by default.
-- `status` identifies missing outputs.
-- `next` renders the correct stage prompt and does not mark Codex-only stages done.
-- `validate` catches invalid SVG, missing hrefs, placeholder slides, and slide count mismatch.
-- `preview` writes HTML that references generated SVG files.
-
-Fixtures:
-
-- `testdata/svglide_run_valid/`
-- `testdata/svglide_run_invalid/`
-
-No live end-to-end test is required for v1 because this version does not call Feishu APIs.
-
-## Acceptance Criteria
-
-- A user can initialize a run directory from local input.
-- Codex can follow generated task prompts stage by stage.
-- The CLI can report status and missing artifacts.
-- The CLI can validate a completed local SVG deck.
-- The CLI can generate local preview HTML.
-- Failed validation produces actionable repair output.
-- No online presentation is created.
-
-## Further Judgment
-
-This design deliberately optimizes for artifact contracts rather than agent-count symmetry. Once the local runtime is stable, individual stages can be split into fuller agents without changing the run directory contract.

internal/svglide/author.go

@@ -1,348 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"fmt"
-	"html"
-	"strings"
-)
-
-const (
-	defaultSlideWidth      = 960
-	defaultSlideHeight     = 540
-	defaultAuthorBgColor   = "#FFFFFF"
-	defaultAuthorInkColor  = "#111827"
-	defaultAuthorMuteColor = "#6B7280"
-	defaultAuthorAccent    = "#2563EB"
-	svgAuthorReceipt       = "receipts/svg_author.json"
-)
-
-type AuthorReport struct {
-	Status string   `json:"status"`
-	Slides []string `json:"slides"`
-}
-
-type authorDeck struct {
-	Title  string            `json:"title"`
-	Slides []authorDeckSlide `json:"slides"`
-}
-
-type authorDeckSlide struct {
-	ID         string `json:"id"`
-	Title      string `json:"title"`
-	Summary    string `json:"summary"`
-	Role       string `json:"role"`
-	KeyMessage string `json:"key_message"`
-	Path       string `json:"path"`
-}
-
-type authorSlideContentFile struct {
-	Slides []authorSlideContent `json:"slides"`
-}
-
-type authorSlideContent struct {
-	ID      string `json:"id"`
-	Content string `json:"content"`
-	Notes   string `json:"notes"`
-}
-
-type authorVisualSystem struct {
-	ColorSystem struct {
-		Background string `json:"background"`
-		Ink        string `json:"ink"`
-		Muted      string `json:"muted"`
-		Accent     string `json:"accent"`
-	} `json:"color_system"`
-	Typography struct {
-		Title int `json:"title"`
-		Body  int `json:"body"`
-	} `json:"typography"`
-	LayoutLanguage string `json:"layout_language"`
-}
-
-type authorTheme struct {
-	Background string
-	Ink        string
-	Muted      string
-	Accent     string
-	TitleSize  int
-	BodySize   int
-}
-
-type authorSlideTarget struct {
-	Slide   authorDeckSlide
-	Content authorSlideContent
-	Path    string
-	Target  string
-	Page    int
-}
-
-func AuthorSlides(root string) (AuthorReport, error) {
-	return authorSlides(root, nil)
-}
-
-func authorSlides(root string, selectedPaths map[string]bool) (AuthorReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return AuthorReport{}, err
-	}
-
-	deck, err := readAuthorDeck(safeRoot, strings.TrimSpace(run.Artifacts.Deck))
-	if err != nil {
-		return AuthorReport{}, err
-	}
-	contentByID, err := readAuthorContent(safeRoot, "content/slide_content.json")
-	if err != nil {
-		return AuthorReport{}, err
-	}
-	theme, err := readAuthorTheme(safeRoot, "brief/visual_system.json")
-	if err != nil {
-		return AuthorReport{}, err
-	}
-	if err := readAuthorJSONContract(safeRoot, "assets/assets_plan.json"); err != nil {
-		return AuthorReport{}, err
-	}
-	if err := validateAuthorDeckContent(deck, contentByID); err != nil {
-		return AuthorReport{}, err
-	}
-
-	targets := make([]authorSlideTarget, 0, len(deck.Slides))
-	report := AuthorReport{
-		Status: StatusDone,
-		Slides: make([]string, 0, len(deck.Slides)),
-	}
-	for i, slide := range deck.Slides {
-		slidePath, err := previewSlideObjectPath(slide.Path)
-		if err != nil {
-			return AuthorReport{}, err
-		}
-		if selectedPaths != nil && !selectedPaths[slidePath] {
-			continue
-		}
-		target, err := ensureRunFileTargetForWrite(safeRoot, slidePath)
-		if err != nil {
-			return AuthorReport{}, err
-		}
-		targets = append(targets, authorSlideTarget{
-			Slide:   slide,
-			Content: contentByID[strings.TrimSpace(slide.ID)],
-			Path:    slidePath,
-			Target:  target,
-			Page:    i + 1,
-		})
-		report.Slides = append(report.Slides, slidePath)
-	}
-	receiptTarget, err := ensureRunFileTargetForWrite(safeRoot, svgAuthorReceipt)
-	if err != nil {
-		return AuthorReport{}, err
-	}
-
-	for _, target := range targets {
-		svg := renderAuthorSVG(deck.Title, target.Slide, target.Content, theme, target.Page, len(deck.Slides))
-		if err := writeText(target.Target, svg); err != nil {
-			return AuthorReport{}, err
-		}
-	}
-	if err := writeJSON(receiptTarget, StageReceipt{
-		Stage:     StageSVGAuthor,
-		Status:    StatusDone,
-		Artifacts: report.Slides,
-	}); err != nil {
-		return AuthorReport{}, err
-	}
-	return report, nil
-}
-
-func readAuthorDeck(safeRoot string, deckPath string) (authorDeck, error) {
-	if deckPath == "" {
-		return authorDeck{}, fmt.Errorf("deck artifact path is empty")
-	}
-	raw, err := readRunRegularArtifact(safeRoot, deckPath)
-	if err != nil {
-		return authorDeck{}, fmt.Errorf("read deck %q: %w", deckPath, err)
-	}
-	var deck authorDeck
-	if err := json.Unmarshal(raw, &deck); err != nil {
-		return authorDeck{}, fmt.Errorf("read deck %q: %w", deckPath, err)
-	}
-	if len(deck.Slides) == 0 {
-		return authorDeck{}, fmt.Errorf("deck %q contains no slides", deckPath)
-	}
-	return deck, nil
-}
-
-func readAuthorContent(safeRoot string, path string) (map[string]authorSlideContent, error) {
-	raw, err := readRunRegularArtifact(safeRoot, path)
-	if err != nil {
-		return nil, fmt.Errorf("read slide content %q: %w", path, err)
-	}
-	var file authorSlideContentFile
-	if err := json.Unmarshal(raw, &file); err != nil {
-		return nil, fmt.Errorf("read slide content %q: %w", path, err)
-	}
-	byID := make(map[string]authorSlideContent, len(file.Slides))
-	for _, slide := range file.Slides {
-		id := strings.TrimSpace(slide.ID)
-		if id == "" {
-			return nil, fmt.Errorf("slide content id must not be empty")
-		}
-		if _, exists := byID[id]; exists {
-			return nil, fmt.Errorf("slide content id %q is duplicated", id)
-		}
-		byID[id] = slide
-	}
-	return byID, nil
-}
-
-func validateAuthorDeckContent(deck authorDeck, contentByID map[string]authorSlideContent) error {
-	deckIDs := make(map[string]bool, len(deck.Slides))
-	for _, slide := range deck.Slides {
-		id := strings.TrimSpace(slide.ID)
-		if id == "" {
-			return fmt.Errorf("deck slide id must not be empty")
-		}
-		if deckIDs[id] {
-			return fmt.Errorf("deck slide id %q is duplicated", id)
-		}
-		deckIDs[id] = true
-		if _, ok := contentByID[id]; !ok {
-			return fmt.Errorf("deck slide id %q is missing from slide content", id)
-		}
-	}
-	return nil
-}
-
-func readAuthorTheme(safeRoot string, path string) (authorTheme, error) {
-	raw, err := readRunRegularArtifact(safeRoot, path)
-	if err != nil {
-		return authorTheme{}, fmt.Errorf("read visual system %q: %w", path, err)
-	}
-	var visual authorVisualSystem
-	if err := json.Unmarshal(raw, &visual); err != nil {
-		return authorTheme{}, fmt.Errorf("read visual system %q: %w", path, err)
-	}
-	theme := authorTheme{
-		Background: normalizeAuthorColor(visual.ColorSystem.Background, defaultAuthorBgColor),
-		Ink:        normalizeAuthorColor(visual.ColorSystem.Ink, defaultAuthorInkColor),
-		Muted:      normalizeAuthorColor(visual.ColorSystem.Muted, defaultAuthorMuteColor),
-		Accent:     normalizeAuthorColor(visual.ColorSystem.Accent, defaultAuthorAccent),
-		TitleSize:  visual.Typography.Title,
-		BodySize:   visual.Typography.Body,
-	}
-	if theme.TitleSize <= 0 {
-		theme.TitleSize = 32
-	}
-	if theme.BodySize <= 0 {
-		theme.BodySize = 16
-	}
-	return theme, nil
-}
-
-func readAuthorJSONContract(safeRoot string, path string) error {
-	raw, err := readRunRegularArtifact(safeRoot, path)
-	if err != nil {
-		return fmt.Errorf("read assets plan %q: %w", path, err)
-	}
-	var contract any
-	if err := json.Unmarshal(raw, &contract); err != nil {
-		return fmt.Errorf("read assets plan %q: %w", path, err)
-	}
-	return nil
-}
-
-func normalizeAuthorColor(value string, fallback string) string {
-	value = strings.TrimSpace(value)
-	if isAllowedAuthorHexColor(value) {
-		return value
-	}
-	return fallback
-}
-
-func isAllowedAuthorHexColor(value string) bool {
-	if len(value) != 4 && len(value) != 7 && len(value) != 9 {
-		return false
-	}
-	if value[0] != '#' {
-		return false
-	}
-	for _, r := range value[1:] {
-		if (r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || (r >= 'A' && r <= 'F') {
-			continue
-		}
-		return false
-	}
-	return true
-}
-
-func renderAuthorSVG(deckTitle string, slide authorDeckSlide, content authorSlideContent, theme authorTheme, page int, total int) string {
-	title := firstNonEmpty(slide.Title, "Untitled slide")
-	keyMessage := firstNonEmpty(slide.KeyMessage, slide.Summary)
-	bodyLines := authorBodyLines(content.Content)
-	footer := strings.TrimSpace(deckTitle)
-	if footer == "" {
-		footer = "SVGlide"
-	}
-
-	var b strings.Builder
-	fmt.Fprintf(&b, `<svg xmlns="%s" xmlns:slide="%s" width="%d" height="%d" viewBox="0 0 960 540" slide:role="slide">`+"\n", svgNamespace, slideNamespace, defaultSlideWidth, defaultSlideHeight)
-	fmt.Fprintf(&b, `  <rect x="0" y="0" width="960" height="540" fill="%s" data-role="background"/>`+"\n", escapeAttr(theme.Background))
-	fmt.Fprintf(&b, `  <rect x="0" y="0" width="960" height="8" fill="%s"/>`+"\n", escapeAttr(theme.Accent))
-	fmt.Fprintf(&b, `  <foreignObject x="56" y="48" width="848" height="404" slide:shape-type="text">`+"\n")
-	fmt.Fprintf(&b, `    <div xmlns="http://www.w3.org/1999/xhtml" style="font-family:Arial, Helvetica, sans-serif;color:%s;">`+"\n", escapeAttr(theme.Ink))
-	fmt.Fprintf(&b, `      <div style="font-size:%dpx;font-weight:700;line-height:1.16;margin-bottom:16px;">%s</div>`+"\n", theme.TitleSize, escapeText(title))
-	if keyMessage != "" {
-		fmt.Fprintf(&b, `      <div style="font-size:%dpx;line-height:1.35;color:%s;margin-bottom:22px;">%s</div>`+"\n", maxInt(theme.BodySize+4, 18), escapeAttr(theme.Accent), escapeText(keyMessage))
-	}
-	fmt.Fprintf(&b, `      <div style="border:1px solid #E5E7EB;border-radius:6px;padding:20px 24px;min-height:190px;background:#F9FAFB;">`+"\n")
-	for _, line := range bodyLines {
-		fmt.Fprintf(&b, `        <div style="font-size:%dpx;line-height:1.55;margin-bottom:8px;">- %s</div>`+"\n", theme.BodySize, escapeText(line))
-	}
-	fmt.Fprintf(&b, "      </div>\n")
-	fmt.Fprintf(&b, "    </div>\n")
-	fmt.Fprintf(&b, "  </foreignObject>\n")
-	fmt.Fprintf(&b, `  <foreignObject x="56" y="482" width="848" height="32" slide:shape-type="text">`+"\n")
-	fmt.Fprintf(&b, `    <div xmlns="http://www.w3.org/1999/xhtml" style="font-family:Arial, Helvetica, sans-serif;color:%s;font-size:12px;display:flex;justify-content:space-between;">`+"\n", escapeAttr(theme.Muted))
-	fmt.Fprintf(&b, "      <span>%s</span><span>%d / %d</span>\n", escapeText(footer), page, total)
-	fmt.Fprintf(&b, "    </div>\n")
-	fmt.Fprintf(&b, "  </foreignObject>\n")
-	fmt.Fprintf(&b, "</svg>\n")
-	return b.String()
-}
-
-func authorBodyLines(content string) []string {
-	var lines []string
-	for _, line := range strings.Split(content, "\n") {
-		line = strings.TrimSpace(line)
-		if line != "" {
-			lines = append(lines, line)
-		}
-	}
-	if len(lines) == 0 {
-		return []string{"No content provided."}
-	}
-	return lines
-}
-
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
-
-func escapeText(value string) string {
-	return html.EscapeString(value)
-}
-
-func escapeAttr(value string) string {
-	return html.EscapeString(value)
-}
-
-func maxInt(a int, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}

internal/svglide/author_test.go

@@ -1,180 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestAuthorSlidesWritesVisibleSVGForEachDeckSlide(t *testing.T) {
-	initStatusTestRun(t)
-
-	mustWriteTestFile(t, "demo/brief/design_brief.json", `{"narrative_spine":"A to B","depth":"medium","tone":"clear"}`)
-	mustWriteTestFile(t, "demo/brief/visual_system.json", `{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`)
-	mustWriteTestFile(t, "demo/outline/deck.json", `{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"},{"id":"s2","title":"Second claim","summary":"Second summary","role":"content","key_message":"Second key message","path":"slides/02.svg"}]}`)
-	mustWriteTestFile(t, "demo/content/slide_content.json", `{"slides":[{"id":"s1","content":"First body line\nSecond body line","notes":"Speaker note"},{"id":"s2","content":"Point A\nPoint B\nPoint C"}]}`)
-	mustWriteTestFile(t, "demo/assets/assets_plan.json", `{"assets":[]}`)
-
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageSVGAuthor
-	writeStatusTestRunFile(t, run)
-
-	report, err := AuthorSlides("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != StatusDone {
-		t.Fatalf("Status = %q, want %q", report.Status, StatusDone)
-	}
-	if len(report.Slides) != 2 {
-		t.Fatalf("Slides len = %d, want 2: %+v", len(report.Slides), report.Slides)
-	}
-	receipt := readAuthorReceiptForTest(t)
-	if receipt["stage"] != StageSVGAuthor {
-		t.Fatalf("receipt stage = %v, want %q", receipt["stage"], StageSVGAuthor)
-	}
-	if receipt["status"] != StatusDone {
-		t.Fatalf("receipt status = %v, want %q", receipt["status"], StatusDone)
-	}
-	if _, ok := receipt["artifacts"].([]any); !ok {
-		t.Fatalf("receipt artifacts = %T, want array", receipt["artifacts"])
-	}
-	if _, ok := receipt["generated_at"]; ok {
-		t.Fatalf("receipt contains generated_at, want StageReceipt-compatible schema: %+v", receipt)
-	}
-
-	for _, rel := range []string{"slides/01.svg", "slides/02.svg"} {
-		raw, err := os.ReadFile(filepath.Join("demo", rel))
-		if err != nil {
-			t.Fatalf("missing %s: %v", rel, err)
-		}
-		svg := string(raw)
-		for _, want := range []string{
-			`slide:role="slide"`,
-			`viewBox="0 0 960 540"`,
-			`foreignObject`,
-			`slide:shape-type="text"`,
-		} {
-			if !strings.Contains(svg, want) {
-				t.Fatalf("%s missing %q:\n%s", rel, want, svg)
-			}
-		}
-	}
-
-	validation, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !validation.OK {
-		t.Fatalf("ValidateRun OK = false, issues: %+v", validation.Issues)
-	}
-}
-
-func TestAuthorSlidesFallsBackForUnsafeColorTokens(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"url(https://example.com/bg.svg)","ink":"red;background:url(https://example.com/x)","muted":"not-a-color","accent":"#abc"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"}]}`,
-	)
-
-	if _, err := AuthorSlides("demo"); err != nil {
-		t.Fatal(err)
-	}
-
-	raw, err := os.ReadFile(filepath.Join("demo", "slides", "01.svg"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	svg := string(raw)
-	for _, banned := range []string{"url(", "https://example.com", "red;background", "not-a-color"} {
-		if strings.Contains(svg, banned) {
-			t.Fatalf("SVG contains unsafe color token %q:\n%s", banned, svg)
-		}
-	}
-	for _, want := range []string{`fill="#FFFFFF"`, `color:#111827`, `color:#6B7280`, `fill="#abc"`, `color:#abc`} {
-		if !strings.Contains(svg, want) {
-			t.Fatalf("SVG missing normalized/default color %q:\n%s", want, svg)
-		}
-	}
-}
-
-func TestAuthorSlidesPreflightsSlidePathsBeforeWriting(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"},{"id":"s2","title":"Second claim","summary":"Second summary","role":"content","key_message":"Second key message","path":"slides/../02.svg"}]}`,
-	)
-
-	if _, err := AuthorSlides("demo"); err == nil {
-		t.Fatal("expected invalid second slide path to fail")
-	}
-	if _, err := os.Stat(filepath.Join("demo", "slides", "01.svg")); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("first slide output exists after preflight failure, stat err = %v", err)
-	}
-}
-
-func TestAuthorSlidesRejectsMissingContentBeforeWriting(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"},{"id":"s2","title":"Second claim","summary":"Second summary","role":"content","key_message":"Second key message","path":"slides/02.svg"}]}`,
-	)
-	mustWriteTestFile(t, "demo/content/slide_content.json", `{"slides":[{"id":"s1","content":"First body line"}]}`)
-
-	if _, err := AuthorSlides("demo"); err == nil {
-		t.Fatal("expected missing slide content to fail")
-	}
-	for _, rel := range []string{"slides/01.svg", "receipts/svg_author.json"} {
-		if _, err := os.Stat(filepath.Join("demo", rel)); !errors.Is(err, os.ErrNotExist) {
-			t.Fatalf("%s exists after content preflight failure, stat err = %v", rel, err)
-		}
-	}
-}
-
-func TestAuthorSlidesRejectsDuplicateContentID(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"}]}`,
-	)
-	mustWriteTestFile(t, "demo/content/slide_content.json", `{"slides":[{"id":"s1","content":"First body line"},{"id":"s1","content":"Duplicate body line"}]}`)
-
-	if _, err := AuthorSlides("demo"); err == nil {
-		t.Fatal("expected duplicate slide content id to fail")
-	}
-	if _, err := os.Stat(filepath.Join("demo", "receipts", "svg_author.json")); !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("svg_author receipt exists after duplicate content id failure, stat err = %v", err)
-	}
-}
-
-func initAuthorDemoRun(t *testing.T, visualSystem string, deck string) {
-	t.Helper()
-	initStatusTestRun(t)
-	mustWriteTestFile(t, "demo/brief/design_brief.json", `{"narrative_spine":"A to B","depth":"medium","tone":"clear"}`)
-	mustWriteTestFile(t, "demo/brief/visual_system.json", visualSystem)
-	mustWriteTestFile(t, "demo/outline/deck.json", deck)
-	mustWriteTestFile(t, "demo/content/slide_content.json", `{"slides":[{"id":"s1","content":"First body line\nSecond body line","notes":"Speaker note"},{"id":"s2","content":"Point A\nPoint B\nPoint C"}]}`)
-	mustWriteTestFile(t, "demo/assets/assets_plan.json", `{"assets":[]}`)
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageSVGAuthor
-	writeStatusTestRunFile(t, run)
-}
-
-func readAuthorReceiptForTest(t *testing.T) map[string]any {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("demo", "receipts", "svg_author.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var receipt map[string]any
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatal(err)
-	}
-	return receipt
-}
-
-func mustWriteTestFile(t *testing.T, path string, content string) {
-	t.Helper()
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}

internal/svglide/init.go

@@ -1,198 +0,0 @@
-package svglide
-
-import (
-	"bytes"
-	"fmt"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-type InitOptions struct {
-	Title        string
-	Input        string
-	Audience     string
-	DeliveryMode string
-	Pages        int
-	Now          time.Time
-	Overwrite    bool
-}
-
-func InitRun(root string, opts InitOptions) error {
-	root = strings.TrimSpace(root)
-	opts.Title = strings.TrimSpace(opts.Title)
-	opts.Input = strings.TrimSpace(opts.Input)
-	if root == "" {
-		return fmt.Errorf("out path is required")
-	}
-	if opts.Title == "" {
-		return fmt.Errorf("title is required")
-	}
-	if opts.Input == "" {
-		return fmt.Errorf("input is required")
-	}
-	safeRoot, err := validate.SafeOutputPath(root)
-	if err != nil {
-		return err
-	}
-	if err := validateRunRoot(root, safeRoot); err != nil {
-		return err
-	}
-	safeInput, err := validate.SafeInputPath(opts.Input)
-	if err != nil {
-		return err
-	}
-	if err := validateInputOutsideRunRoot(safeRoot, safeInput); err != nil {
-		return err
-	}
-	opts.Input = safeInput
-
-	if opts.Overwrite {
-		return initOverwrite(safeRoot, opts)
-	}
-
-	return initNoReplace(safeRoot, opts)
-}
-
-func validateRunRoot(root string, safeRoot string) error {
-	if filepath.Clean(root) == "." {
-		return fmt.Errorf("out path must be a child directory, got %q", root)
-	}
-	cwd, err := vfs.Getwd()
-	if err != nil {
-		return fmt.Errorf("cannot determine working directory: %w", err)
-	}
-	canonicalCwd, err := vfs.EvalSymlinks(cwd)
-	if err != nil {
-		return fmt.Errorf("cannot resolve working directory: %w", err)
-	}
-	if filepath.Clean(safeRoot) == filepath.Clean(canonicalCwd) {
-		return fmt.Errorf("out path must be a child directory, got %q", root)
-	}
-	return nil
-}
-
-func validateInputOutsideRunRoot(safeRoot string, safeInput string) error {
-	root := filepath.Clean(safeRoot)
-	input := filepath.Clean(safeInput)
-	rel, err := filepath.Rel(root, input)
-	if err != nil {
-		return fmt.Errorf("cannot compare input and output paths: %w", err)
-	}
-	if rel == "." || (rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator))) {
-		return fmt.Errorf("input path %q must be outside output run directory %q", safeInput, safeRoot)
-	}
-	return nil
-}
-
-func initNoReplace(safeRoot string, opts InitOptions) error {
-	if err := vfs.MkdirAll(filepath.Dir(safeRoot), 0o755); err != nil {
-		return err
-	}
-	if err := vfs.Mkdir(safeRoot, 0o755); err != nil {
-		return fmt.Errorf("%s already exists or cannot be created; refusing to overwrite: %w", safeRoot, err)
-	}
-	return writeClaimedRunDirectory(safeRoot, opts)
-}
-
-func initOverwrite(safeRoot string, opts InitOptions) error {
-	if err := vfs.RemoveAll(safeRoot); err != nil {
-		return err
-	}
-	if err := vfs.MkdirAll(filepath.Dir(safeRoot), 0o755); err != nil {
-		return err
-	}
-	if err := vfs.Mkdir(safeRoot, 0o755); err != nil {
-		return err
-	}
-	return writeClaimedRunDirectory(safeRoot, opts)
-}
-
-func writeClaimedRunDirectory(safeRoot string, opts InitOptions) error {
-	cleanup := true
-	defer func() {
-		if cleanup {
-			_ = vfs.RemoveAll(safeRoot)
-		}
-	}()
-	if err := writeRunDirectory(safeRoot, safeRoot, opts); err != nil {
-		return err
-	}
-	cleanup = false
-	return nil
-}
-
-func writeRunDirectory(writeRoot string, runRoot string, opts InitOptions) error {
-	for _, dir := range []string{
-		"request",
-		"research",
-		"brief",
-		"outline",
-		"content",
-		"assets/images",
-		"assets/charts",
-		"slides",
-		"prompts",
-		"schemas",
-		"receipts",
-	} {
-		if err := vfs.MkdirAll(filepath.Join(writeRoot, dir), 0o755); err != nil {
-			return err
-		}
-	}
-	run := NewRun(NewRunConfig{
-		Title:        opts.Title,
-		Input:        opts.Input,
-		Audience:     opts.Audience,
-		DeliveryMode: opts.DeliveryMode,
-		Pages:        opts.Pages,
-		Out:          runRoot,
-		Now:          opts.Now,
-	})
-	run.Policy.Overwrite = opts.Overwrite
-	if err := writeJSON(filepath.Join(writeRoot, "run.json"), run); err != nil {
-		return err
-	}
-	if err := writeJSON(filepath.Join(writeRoot, "request", "request.json"), map[string]any{
-		"title":         opts.Title,
-		"input":         opts.Input,
-		"audience":      opts.Audience,
-		"delivery_mode": opts.DeliveryMode,
-		"pages":         opts.Pages,
-	}); err != nil {
-		return err
-	}
-	if err := writeJSON(filepath.Join(writeRoot, "request", "source_manifest.json"), map[string]any{
-		"sources": []map[string]string{{"path": opts.Input, "type": "local"}},
-	}); err != nil {
-		return err
-	}
-	return writeStaticFiles(writeRoot)
-}
-
-func writeStaticFiles(root string) error {
-	if err := writeText(filepath.Join(root, "README.md"), renderRunREADME()); err != nil {
-		return err
-	}
-	for _, prompt := range DefaultPromptFiles() {
-		if err := writeText(filepath.Join(root, "prompts", prompt.Name), prompt.Content); err != nil {
-			return err
-		}
-	}
-	for name, schema := range DefaultSchemas() {
-		if err := writeText(filepath.Join(root, "schemas", name), schema); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func renderRunREADME() string {
-	var b bytes.Buffer
-	b.WriteString("# SVGlide Local Run\n\n")
-	b.WriteString("This directory is a local Codex-mediated SVG slides runtime. It does not publish to Feishu Slides.\n")
-	return b.String()
-}

internal/svglide/init_test.go

@@ -1,369 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestInitRunWritesDirectoryContract(t *testing.T) {
-	cwd := t.TempDir()
-	t.Chdir(cwd)
-	canonicalCwd, err := filepath.EvalSymlinks(cwd)
-	if err != nil {
-		t.Fatal(err)
-	}
-	root := "demo"
-	wantInput := filepath.Join(canonicalCwd, "source.md")
-	err = InitRun(root, InitOptions{
-		Title:        "Demo",
-		Input:        "source.md",
-		Audience:     "产品负责人",
-		DeliveryMode: "self_read",
-		Pages:        8,
-		Now:          time.Date(2026, 7, 2, 20, 0, 0, 0, time.FixedZone("CST", 8*3600)),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range []string{
-		"run.json",
-		"README.md",
-		"request/request.json",
-		"request/source_manifest.json",
-		"research",
-		"brief",
-		"outline",
-		"content",
-		"prompts/01_request.task.md",
-		"prompts/07_svg_author.task.md",
-		"schemas/request.schema.json",
-		"schemas/deck.schema.json",
-		"receipts",
-		"slides",
-		"assets/charts",
-		"assets/images",
-	} {
-		if _, err := os.Stat(filepath.Join(root, name)); err != nil {
-			t.Fatalf("missing %s: %v", name, err)
-		}
-	}
-	raw, err := os.ReadFile(filepath.Join(root, "run.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var run Run
-	if err := json.Unmarshal(raw, &run); err != nil {
-		t.Fatal(err)
-	}
-	if run.Title != "Demo" || run.CurrentStage != StageRequest {
-		t.Fatalf("unexpected run: %+v", run)
-	}
-	if run.Input != wantInput {
-		t.Fatalf("run.Input = %q, want %q", run.Input, wantInput)
-	}
-
-	requestRaw, err := os.ReadFile(filepath.Join(root, "request", "request.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var request map[string]any
-	if err := json.Unmarshal(requestRaw, &request); err != nil {
-		t.Fatal(err)
-	}
-	if request["title"] != "Demo" || request["input"] != wantInput || request["audience"] != "产品负责人" || request["delivery_mode"] != "self_read" || request["pages"] != float64(8) {
-		t.Fatalf("unexpected request.json: %+v", request)
-	}
-
-	manifestRaw, err := os.ReadFile(filepath.Join(root, "request", "source_manifest.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var manifest struct {
-		Sources []struct {
-			Path string `json:"path"`
-			Type string `json:"type"`
-		} `json:"sources"`
-	}
-	if err := json.Unmarshal(manifestRaw, &manifest); err != nil {
-		t.Fatal(err)
-	}
-	if len(manifest.Sources) != 1 || manifest.Sources[0].Path != wantInput || manifest.Sources[0].Type != "local" {
-		t.Fatalf("unexpected source_manifest.json: %+v", manifest)
-	}
-
-	promptRaw, err := os.ReadFile(filepath.Join(root, "prompts", "07_svg_author.task.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	prompt := string(promptRaw)
-	for _, want := range []string{"Inputs", "Outputs", "Receipt", "禁止只写背景"} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("svg author prompt missing %q:\n%s", want, prompt)
-		}
-	}
-
-	schemaRaw, err := os.ReadFile(filepath.Join(root, "schemas", "deck.schema.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var deckSchema map[string]any
-	if err := json.Unmarshal(schemaRaw, &deckSchema); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := deckSchema["properties"]; !ok || !strings.Contains(string(schemaRaw), "key_message") {
-		t.Fatalf("deck schema missing properties/key_message: %s", string(schemaRaw))
-	}
-	if !strings.Contains(string(schemaRaw), `"minItems": 1`) || !strings.Contains(string(schemaRaw), `^slides/[^/]+\\.svg$`) {
-		t.Fatalf("deck schema missing minItems/path pattern: %s", string(schemaRaw))
-	}
-	for _, name := range []string{
-		"source_manifest.schema.json",
-		"sources.schema.json",
-		"receipt.schema.json",
-		"lint.schema.json",
-		"preview.schema.json",
-	} {
-		raw, err := os.ReadFile(filepath.Join(root, "schemas", name))
-		if err != nil {
-			t.Fatalf("missing schema %s: %v", name, err)
-		}
-		var schema map[string]any
-		if err := json.Unmarshal(raw, &schema); err != nil {
-			t.Fatalf("schema %s is not valid JSON: %v", name, err)
-		}
-		if schema["type"] == nil {
-			t.Fatalf("schema %s missing type: %s", name, string(raw))
-		}
-	}
-}
-
-func TestInitRunRefusesExistingRunJSON(t *testing.T) {
-	t.Chdir(t.TempDir())
-	root := "demo"
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "run.json"), []byte("{}"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	err := InitRun(root, InitOptions{Title: "Demo", Input: "source.md"})
-	if err == nil {
-		t.Fatal("expected overwrite refusal")
-	}
-}
-
-func TestInitRunRefusesExistingRootWithoutRunJSON(t *testing.T) {
-	t.Chdir(t.TempDir())
-	root := "demo"
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	wantREADME := "keep this readme\n"
-	if err := os.WriteFile(filepath.Join(root, "README.md"), []byte(wantREADME), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	err := InitRun(root, InitOptions{Title: "Demo", Input: "source.md"})
-	gotREADME, readErr := os.ReadFile(filepath.Join(root, "README.md"))
-	if readErr != nil {
-		t.Fatal(readErr)
-	}
-	if string(gotREADME) != wantREADME {
-		t.Fatalf("README overwritten: got %q, want %q", string(gotREADME), wantREADME)
-	}
-	if err == nil {
-		t.Fatal("expected existing root refusal")
-	}
-}
-
-func TestInitRunOverwriteReplacesOldRunDirectory(t *testing.T) {
-	t.Chdir(t.TempDir())
-	root := "demo"
-	if err := os.MkdirAll(filepath.Join(root, "slides"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "slides", "old.svg"), []byte("<svg/>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	err := InitRun(root, InitOptions{Title: "Demo", Input: "source.md", Overwrite: true})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(root, "slides", "old.svg")); !os.IsNotExist(err) {
-		t.Fatalf("old slide should be removed, stat err = %v", err)
-	}
-	raw, err := os.ReadFile(filepath.Join(root, "run.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var run Run
-	if err := json.Unmarshal(raw, &run); err != nil {
-		t.Fatal(err)
-	}
-	if !run.Policy.Overwrite {
-		t.Fatalf("Policy.Overwrite = false, want true: %+v", run.Policy)
-	}
-}
-
-func TestInitRunRejectsOverlappingInputAndOutput(t *testing.T) {
-	tests := []struct {
-		name      string
-		root      string
-		input     string
-		overwrite bool
-	}{
-		{name: "same path overwrite", root: "source.md", input: "source.md", overwrite: true},
-		{name: "input under output overwrite", root: "demo", input: "demo/source.md", overwrite: true},
-		{name: "input under output no overwrite", root: "demo", input: "demo/source.md", overwrite: false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Chdir(t.TempDir())
-			if err := os.MkdirAll(filepath.Dir(tt.input), 0o755); err != nil {
-				t.Fatal(err)
-			}
-			if err := os.WriteFile(tt.input, []byte("source"), 0o644); err != nil {
-				t.Fatal(err)
-			}
-
-			err := InitRun(tt.root, InitOptions{Title: "Demo", Input: tt.input, Overwrite: tt.overwrite})
-			if err == nil {
-				t.Fatal("expected overlapping input/output refusal")
-			}
-			got, readErr := os.ReadFile(tt.input)
-			if readErr != nil {
-				t.Fatalf("source should remain readable: %v", readErr)
-			}
-			if string(got) != "source" {
-				t.Fatalf("source content changed: got %q", string(got))
-			}
-		})
-	}
-}
-
-func TestInitRunRejectsUnsafePaths(t *testing.T) {
-	cwd := t.TempDir()
-	t.Chdir(cwd)
-	tests := []struct {
-		name string
-		root string
-		opts InitOptions
-	}{
-		{name: "absolute root", root: filepath.Join(cwd, "demo"), opts: InitOptions{Title: "Demo", Input: "source.md"}},
-		{name: "escaping root", root: "../escape", opts: InitOptions{Title: "Demo", Input: "source.md"}},
-		{name: "escaping input", root: "demo", opts: InitOptions{Title: "Demo", Input: "../source.md"}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := InitRun(tt.root, tt.opts); err == nil {
-				t.Fatal("expected unsafe path refusal")
-			}
-		})
-	}
-}
-
-func TestInitRunRejectsRootResolvingToCWDWhenOverwrite(t *testing.T) {
-	for _, root := range []string{".", "./", "subdir/.."} {
-		t.Run(root, func(t *testing.T) {
-			cwd := t.TempDir()
-			t.Chdir(cwd)
-			markerPath := filepath.Join(cwd, "keep.txt")
-			if err := os.WriteFile(markerPath, []byte("keep"), 0o644); err != nil {
-				t.Fatal(err)
-			}
-
-			err := InitRun(root, InitOptions{Title: "Demo", Input: "source.md", Overwrite: true})
-			if err == nil {
-				t.Fatal("expected root resolving to CWD to be rejected")
-			}
-			got, readErr := os.ReadFile(markerPath)
-			if readErr != nil {
-				t.Fatalf("marker should remain readable: %v", readErr)
-			}
-			if string(got) != "keep" {
-				t.Fatalf("marker content changed: got %q", string(got))
-			}
-		})
-	}
-}
-
-func TestDefaultPromptFilesValidatePreviewRepairMatchesStageContract(t *testing.T) {
-	var repairPrompt string
-	for _, prompt := range DefaultPromptFiles() {
-		if prompt.Name == "08_repair.task.md" {
-			repairPrompt = prompt.Content
-			break
-		}
-	}
-	if repairPrompt == "" {
-		t.Fatal("missing 08_repair.task.md")
-	}
-	wantOutputs := []string{
-		"receipts/lint.json",
-		"receipts/preview.json",
-		"repair_queue.md",
-		"preview.html",
-	}
-	if got := promptSectionItems(repairPrompt, "Outputs"); !sameStrings(got, wantOutputs) {
-		t.Fatalf("08_repair Outputs = %v, want %v\n%s", got, wantOutputs, repairPrompt)
-	}
-	if got := promptSectionItems(repairPrompt, "Receipt"); !sameStrings(got, []string{"receipts/validate_preview_repair.json"}) {
-		t.Fatalf("08_repair Receipt = %v, want receipts/validate_preview_repair.json\n%s", got, repairPrompt)
-	}
-}
-
-func promptSectionItems(content string, section string) []string {
-	lines := strings.Split(content, "\n")
-	inSection := false
-	var items []string
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == section+":" {
-			inSection = true
-			continue
-		}
-		if inSection && strings.HasSuffix(trimmed, ":") {
-			break
-		}
-		if inSection && strings.HasPrefix(trimmed, "- ") {
-			items = append(items, strings.TrimSpace(strings.TrimPrefix(trimmed, "- ")))
-		}
-	}
-	return items
-}
-
-func sameStrings(got []string, want []string) bool {
-	if len(got) != len(want) {
-		return false
-	}
-	for i := range got {
-		if got[i] != want[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func TestInitRunRejectsBlankRequiredFields(t *testing.T) {
-	blankRoot := "   "
-	t.Chdir(t.TempDir())
-	tests := []struct {
-		name string
-		root string
-		opts InitOptions
-	}{
-		{name: "root", root: blankRoot, opts: InitOptions{Title: "Demo", Input: "source.md"}},
-		{name: "title", root: "title", opts: InitOptions{Title: "  \t", Input: "source.md"}},
-		{name: "input", root: "input", opts: InitOptions{Title: "Demo", Input: "  \t"}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := InitRun(tt.root, tt.opts); err == nil {
-				t.Fatal("expected blank field refusal")
-			}
-		})
-	}
-}

internal/svglide/io.go

@@ -1,20 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-
-	"github.com/larksuite/cli/internal/validate"
-)
-
-func writeJSON(path string, value any) error {
-	raw, err := json.MarshalIndent(value, "", "  ")
-	if err != nil {
-		return err
-	}
-	raw = append(raw, '\n')
-	return validate.AtomicWrite(path, raw, 0o644)
-}
-
-func writeText(path string, content string) error {
-	return validate.AtomicWrite(path, []byte(content), 0o644)
-}

internal/svglide/preview.go

@@ -1,431 +0,0 @@
-package svglide
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"html/template"
-	"path/filepath"
-	"strings"
-
-	"github.com/larksuite/cli/internal/validate"
-)
-
-const defaultPreviewPath = "preview.html"
-const previewReceiptPath = "receipts/preview.json"
-
-type PreviewReport struct {
-	Status string               `json:"status"`
-	Slides []PreviewSlideReport `json:"slides"`
-}
-
-type PreviewSlideReport struct {
-	Path     string `json:"path"`
-	Rendered bool   `json:"rendered"`
-	Message  string `json:"message,omitempty"`
-}
-
-type previewDeck struct {
-	Title  string             `json:"title"`
-	Slides []previewDeckSlide `json:"slides"`
-}
-
-type previewDeckSlide struct {
-	ID         string `json:"id"`
-	Title      string `json:"title"`
-	Summary    string `json:"summary"`
-	Role       string `json:"role"`
-	KeyMessage string `json:"key_message"`
-	Path       string `json:"path"`
-}
-
-type previewPageData struct {
-	Title         string
-	Status        string
-	SlideCount    int
-	RenderedCount int
-	Slides        []previewPageSlide
-}
-
-type previewPageSlide struct {
-	Number     int
-	ID         string
-	Title      string
-	Summary    string
-	Role       string
-	KeyMessage string
-	Path       string
-	Rendered   bool
-	Message    string
-}
-
-func WritePreview(root string) (PreviewReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return PreviewReport{}, err
-	}
-
-	deckPath := strings.TrimSpace(run.Artifacts.Deck)
-	if deckPath == "" {
-		return writeFailedPreview(safeRoot, run, "", "deck artifact path is empty")
-	}
-	deckRaw, err := readRunRegularArtifact(safeRoot, deckPath)
-	if err != nil {
-		return writeFailedPreview(safeRoot, run, deckPath, fmt.Sprintf("deck %q: %v", deckPath, err))
-	}
-	var deck previewDeck
-	if err := json.Unmarshal(deckRaw, &deck); err != nil {
-		return writeFailedPreview(safeRoot, run, deckPath, fmt.Sprintf("deck %q contains invalid JSON: %v", deckPath, err))
-	}
-	if len(deck.Slides) == 0 {
-		return writeFailedPreview(safeRoot, run, deckPath, fmt.Sprintf("deck %q contains no slides", deckPath))
-	}
-
-	report := PreviewReport{Slides: make([]PreviewSlideReport, 0, len(deck.Slides))}
-	pageSlides := make([]previewPageSlide, 0, len(deck.Slides))
-	for i, slide := range deck.Slides {
-		slidePath, pathErr := previewSlideObjectPath(slide.Path)
-		pageSlide := previewPageSlide{
-			Number:     i + 1,
-			ID:         strings.TrimSpace(slide.ID),
-			Title:      strings.TrimSpace(slide.Title),
-			Summary:    strings.TrimSpace(slide.Summary),
-			Role:       strings.TrimSpace(slide.Role),
-			KeyMessage: strings.TrimSpace(slide.KeyMessage),
-			Path:       slidePath,
-		}
-		item := PreviewSlideReport{Path: slidePath}
-		if pathErr != nil {
-			item.Message = pathErr.Error()
-		} else if slidePath == "" {
-			item.Path = "(slide)"
-			pageSlide.Path = item.Path
-			item.Message = "slide path must not be empty"
-		} else if _, err := readRunRegularArtifact(safeRoot, slidePath); err != nil {
-			item.Message = err.Error()
-		} else {
-			item.Rendered = true
-			pageSlide.Rendered = true
-		}
-		pageSlide.Message = item.Message
-		report.Slides = append(report.Slides, item)
-		pageSlides = append(pageSlides, pageSlide)
-	}
-	report = normalizePreviewReport(report)
-
-	if err := writePreviewArtifacts(safeRoot, run, deck.Title, report, pageSlides); err != nil {
-		return report, err
-	}
-	return report, nil
-}
-
-func writeFailedPreview(safeRoot string, run Run, path string, message string) (PreviewReport, error) {
-	path = strings.TrimSpace(path)
-	if path == "" {
-		path = "(deck)"
-	}
-	report := normalizePreviewReport(PreviewReport{
-		Slides: []PreviewSlideReport{{
-			Path:     path,
-			Rendered: false,
-			Message:  message,
-		}},
-	})
-	pageSlides := []previewPageSlide{{
-		Number:   1,
-		Title:    "Preview failed",
-		Path:     path,
-		Rendered: false,
-		Message:  message,
-	}}
-	if err := writePreviewArtifacts(safeRoot, run, run.Title, report, pageSlides); err != nil {
-		return report, err
-	}
-	return report, nil
-}
-
-func normalizePreviewReport(report PreviewReport) PreviewReport {
-	if report.Slides == nil {
-		report.Slides = []PreviewSlideReport{}
-	}
-	report.Status = "passed"
-	for i := range report.Slides {
-		report.Slides[i].Path = strings.TrimSpace(report.Slides[i].Path)
-		if report.Slides[i].Path == "" {
-			report.Slides[i].Path = "(slide)"
-		}
-		if !report.Slides[i].Rendered {
-			report.Status = "failed"
-		}
-	}
-	return report
-}
-
-func previewSlideObjectPath(path string) (string, error) {
-	raw := strings.TrimSpace(path)
-	if raw == "" {
-		return "", fmt.Errorf("slide path must not be empty")
-	}
-	if strings.Contains(raw, `\`) {
-		return "", fmt.Errorf("slide path %q must use forward slashes", raw)
-	}
-	if strings.Contains(raw, "%") {
-		return "", fmt.Errorf("slide path %q must not contain percent encoding", raw)
-	}
-	if strings.Contains(raw, ":") || strings.Contains(raw, "//") {
-		return "", fmt.Errorf("slide path %q must be a local slides/*.svg path", raw)
-	}
-	parts := strings.Split(raw, "/")
-	if len(parts) != 2 || parts[0] != "slides" {
-		return "", fmt.Errorf("slide path %q must match slides/<file>.svg", raw)
-	}
-	fileName := parts[1]
-	if fileName == "" || fileName == "." || fileName == ".." {
-		return "", fmt.Errorf("slide path %q must include a slide file name", raw)
-	}
-	if strings.Contains(fileName, "/") || strings.Contains(fileName, `\`) {
-		return "", fmt.Errorf("slide path %q must not contain nested directories", raw)
-	}
-	if strings.HasPrefix(fileName, ".") || strings.Contains(fileName, "..") {
-		return "", fmt.Errorf("slide path %q must not contain dot segments", raw)
-	}
-	if strings.ToLower(filepath.Ext(fileName)) != ".svg" {
-		return "", fmt.Errorf("slide path %q must end with .svg", raw)
-	}
-	cleaned := filepath.ToSlash(filepath.Clean(raw))
-	if cleaned != raw {
-		return "", fmt.Errorf("slide path %q must already be normalized", raw)
-	}
-	return raw, nil
-}
-
-func writePreviewArtifacts(safeRoot string, run Run, title string, report PreviewReport, slides []previewPageSlide) error {
-	report = normalizePreviewReport(report)
-	previewPath := strings.TrimSpace(run.Artifacts.Preview)
-	if previewPath == "" {
-		previewPath = defaultPreviewPath
-	}
-	target, err := ensureRunFileTargetForWrite(safeRoot, previewPath)
-	if err != nil {
-		return err
-	}
-	htmlRaw, err := renderPreviewHTML(title, report, slides)
-	if err != nil {
-		return err
-	}
-	if err := validate.AtomicWrite(target, htmlRaw, 0o644); err != nil {
-		return err
-	}
-	receiptTarget, err := ensureRunFileTargetForWrite(safeRoot, previewReceiptPath)
-	if err != nil {
-		return err
-	}
-	raw, err := json.MarshalIndent(report, "", "  ")
-	if err != nil {
-		return err
-	}
-	raw = append(raw, '\n')
-	return validate.AtomicWrite(receiptTarget, raw, 0o644)
-}
-
-func renderPreviewHTML(title string, report PreviewReport, slides []previewPageSlide) ([]byte, error) {
-	title = strings.TrimSpace(title)
-	if title == "" {
-		title = "SVGlide Preview"
-	}
-	var rendered int
-	for _, slide := range slides {
-		if slide.Rendered {
-			rendered++
-		}
-	}
-	data := previewPageData{
-		Title:         title,
-		Status:        report.Status,
-		SlideCount:    len(slides),
-		RenderedCount: rendered,
-		Slides:        slides,
-	}
-	var b bytes.Buffer
-	if err := previewTemplate.Execute(&b, data); err != nil {
-		return nil, err
-	}
-	return b.Bytes(), nil
-}
-
-var previewTemplate = template.Must(template.New("preview").Parse(`<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>{{.Title}} - SVGlide Preview</title>
-  <style>
-    :root {
-      color-scheme: light;
-      --bg: #f6f7f9;
-      --panel: #ffffff;
-      --ink: #1f2933;
-      --muted: #657286;
-      --line: #d8dee8;
-      --accent: #1d7a62;
-      --warn: #b42318;
-    }
-    * { box-sizing: border-box; }
-    body {
-      margin: 0;
-      background: var(--bg);
-      color: var(--ink);
-      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      line-height: 1.45;
-    }
-    header {
-      position: sticky;
-      top: 0;
-      z-index: 2;
-      border-bottom: 1px solid var(--line);
-      background: rgba(255,255,255,.94);
-      backdrop-filter: blur(10px);
-    }
-    .bar {
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      gap: 24px;
-      max-width: 1180px;
-      margin: 0 auto;
-      padding: 18px 24px;
-    }
-    h1 {
-      margin: 0;
-      font-size: 20px;
-      font-weight: 650;
-      letter-spacing: 0;
-    }
-    .meta {
-      display: flex;
-      align-items: center;
-      gap: 10px;
-      color: var(--muted);
-      font-size: 13px;
-      white-space: nowrap;
-    }
-    .status {
-      color: #fff;
-      background: var(--accent);
-      border-radius: 999px;
-      padding: 3px 9px;
-      font-weight: 650;
-    }
-    .status.failed { background: var(--warn); }
-    main {
-      max-width: 1180px;
-      margin: 0 auto;
-      padding: 22px 24px 48px;
-    }
-    .deck {
-      display: grid;
-      gap: 18px;
-    }
-    .slide {
-      display: grid;
-      grid-template-columns: minmax(0, 1fr) 260px;
-      gap: 16px;
-      align-items: start;
-      border: 1px solid var(--line);
-      border-radius: 8px;
-      background: var(--panel);
-      padding: 16px;
-      box-shadow: 0 12px 24px rgba(31,41,51,.06);
-    }
-    .frame {
-      width: 100%;
-      aspect-ratio: 16 / 9;
-      overflow: hidden;
-      border: 1px solid var(--line);
-      border-radius: 6px;
-      background: #fff;
-    }
-    object {
-      display: block;
-      width: 100%;
-      height: 100%;
-      border: 0;
-    }
-    .missing {
-      display: grid;
-      place-items: center;
-      width: 100%;
-      height: 100%;
-      padding: 24px;
-      color: var(--warn);
-      text-align: center;
-      font-size: 14px;
-    }
-    .details {
-      min-width: 0;
-      display: grid;
-      gap: 10px;
-      color: var(--muted);
-      font-size: 13px;
-    }
-    .details h2 {
-      margin: 0;
-      color: var(--ink);
-      font-size: 16px;
-      font-weight: 650;
-      letter-spacing: 0;
-      overflow-wrap: anywhere;
-    }
-    .label {
-      color: var(--ink);
-      font-weight: 650;
-    }
-    .path {
-      overflow-wrap: anywhere;
-      font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-      font-size: 12px;
-    }
-    .message { color: var(--warn); overflow-wrap: anywhere; }
-    @media (max-width: 860px) {
-      .bar { align-items: flex-start; flex-direction: column; gap: 8px; }
-      .meta { flex-wrap: wrap; white-space: normal; }
-      .slide { grid-template-columns: 1fr; }
-    }
-  </style>
-</head>
-<body>
-  <header>
-    <div class="bar">
-      <h1>{{.Title}}</h1>
-      <div class="meta">
-        <span class="status {{.Status}}">{{.Status}}</span>
-        <span>{{.RenderedCount}} / {{.SlideCount}} rendered</span>
-      </div>
-    </div>
-  </header>
-  <main>
-    <section class="deck">
-      {{range .Slides}}
-      <article class="slide">
-        <div class="frame">
-          {{if .Rendered}}
-          <object data="{{.Path}}" type="image/svg+xml" aria-label="{{.Title}}"></object>
-          {{else}}
-          <div class="missing">{{.Message}}</div>
-          {{end}}
-        </div>
-        <div class="details">
-          <h2>{{printf "%02d" .Number}}. {{.Title}}</h2>
-          {{if .Summary}}<div><span class="label">Summary</span><br>{{.Summary}}</div>{{end}}
-          {{if .KeyMessage}}<div><span class="label">Key Message</span><br>{{.KeyMessage}}</div>{{end}}
-          {{if .Role}}<div><span class="label">Role</span><br>{{.Role}}</div>{{end}}
-          <div><span class="label">Path</span><br><span class="path">{{.Path}}</span></div>
-          {{if .Message}}<div class="message">{{.Message}}</div>{{end}}
-        </div>
-      </article>
-      {{end}}
-    </section>
-  </main>
-</body>
-</html>
-`))

internal/svglide/preview_test.go

@@ -1,299 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestWritePreviewWritesHTMLAndReceipt(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-
-	report, err := WritePreview("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "passed" {
-		t.Fatalf("Status = %q, want passed: %+v", report.Status, report)
-	}
-	if len(report.Slides) != 1 || !report.Slides[0].Rendered || report.Slides[0].Path != "slides/01.svg" {
-		t.Fatalf("Slides = %+v, want rendered slides/01.svg", report.Slides)
-	}
-
-	htmlRaw, err := os.ReadFile(filepath.Join("demo", "preview.html"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	html := string(htmlRaw)
-	for _, want := range []string{"Demo - SVGlide Preview", `data="slides/01.svg"`, "01. Slide", "Key Message"} {
-		if !strings.Contains(html, want) {
-			t.Fatalf("preview.html missing %q:\n%s", want, html)
-		}
-	}
-
-	receipt := readPreviewReceipt(t)
-	if receipt.Status != "passed" || len(receipt.Slides) != 1 || !receipt.Slides[0].Rendered {
-		t.Fatalf("preview receipt = %+v, want passed rendered slide", receipt)
-	}
-}
-
-func TestWritePreviewEscapesDeckText(t *testing.T) {
-	initValidateTestRun(t)
-	writeDeckAt(t, filepath.Join("demo", "outline", "deck.json"), previewDeck{
-		Title: `<Deck & Demo>`,
-		Slides: []previewDeckSlide{{
-			ID:         "cover",
-			Title:      `<Cover & One>`,
-			Summary:    `Summary <script>bad()</script>`,
-			Role:       "cover",
-			KeyMessage: `Message & context`,
-			Path:       "slides/01.svg",
-		}},
-	})
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-
-	if _, err := WritePreview("demo"); err != nil {
-		t.Fatal(err)
-	}
-
-	htmlRaw, err := os.ReadFile(filepath.Join("demo", "preview.html"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	html := string(htmlRaw)
-	if strings.Contains(html, "<script>bad()</script>") {
-		t.Fatalf("preview.html contains unescaped script:\n%s", html)
-	}
-	if !strings.Contains(html, "&lt;script&gt;bad()&lt;/script&gt;") || !strings.Contains(html, "&lt;Deck &amp; Demo&gt;") {
-		t.Fatalf("preview.html missing escaped deck text:\n%s", html)
-	}
-}
-
-func TestWritePreviewUsesRunArtifactDeckAndPreviewPath(t *testing.T) {
-	initValidateTestRun(t)
-	run := readValidateTestRunFile(t)
-	run.Artifacts.Deck = "custom/deck.json"
-	run.Artifacts.Preview = "public/deck.html"
-	writeValidateTestRunFile(t, run)
-	writeMinimalDeck(t, "demo", "slides/missing.svg")
-	writeMinimalDeckAt(t, filepath.Join("demo", "custom", "deck.json"), "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-
-	report, err := WritePreview("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "passed" {
-		t.Fatalf("Status = %q, want passed: %+v", report.Status, report)
-	}
-	if _, err := os.Stat(filepath.Join("demo", "public", "deck.html")); err != nil {
-		t.Fatalf("missing custom preview path: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join("demo", "preview.html")); !os.IsNotExist(err) {
-		t.Fatalf("default preview should not be written when artifact path is custom, stat err=%v", err)
-	}
-}
-
-func TestWritePreviewReportsUnsafeSlidePath(t *testing.T) {
-	tests := []struct {
-		name        string
-		slidePath   string
-		filePath    string
-		wantMessage string
-	}{
-		{
-			name:        "escape",
-			slidePath:   "../outside.svg",
-			filePath:    "outside.svg",
-			wantMessage: "slides/<file>.svg",
-		},
-		{
-			name:        "remote scheme",
-			slidePath:   "https:/evil.example/a.svg",
-			filePath:    filepath.Join("demo", "https:", "evil.example", "a.svg"),
-			wantMessage: "local slides/*.svg",
-		},
-		{
-			name:        "encoded dot segment",
-			slidePath:   "slides/%2e%2e.svg",
-			filePath:    filepath.Join("demo", "slides", "%2e%2e.svg"),
-			wantMessage: "percent encoding",
-		},
-		{
-			name:        "nested directory",
-			slidePath:   "slides/nested/01.svg",
-			filePath:    filepath.Join("demo", "slides", "nested", "01.svg"),
-			wantMessage: "slides/<file>.svg",
-		},
-		{
-			name:        "backslash",
-			slidePath:   `slides\01.svg`,
-			filePath:    filepath.Join("demo", `slides\01.svg`),
-			wantMessage: "forward slashes",
-		},
-		{
-			name:        "wrong extension",
-			slidePath:   "slides/01.png",
-			filePath:    filepath.Join("demo", "slides", "01.png"),
-			wantMessage: ".svg",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", tt.slidePath)
-			writeValidateTestFile(t, tt.filePath, visibleTextSVG())
-
-			report, err := WritePreview("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.Status != "failed" {
-				t.Fatalf("Status = %q, want failed: %+v", report.Status, report)
-			}
-			if len(report.Slides) != 1 || report.Slides[0].Rendered {
-				t.Fatalf("Slides = %+v, want unrendered slide", report.Slides)
-			}
-			if !strings.Contains(report.Slides[0].Message, tt.wantMessage) {
-				t.Fatalf("Message = %q, want %q", report.Slides[0].Message, tt.wantMessage)
-			}
-			receipt := readPreviewReceipt(t)
-			if receipt.Status != "failed" || len(receipt.Slides) != 1 || receipt.Slides[0].Rendered {
-				t.Fatalf("preview receipt = %+v, want failed unrendered slide", receipt)
-			}
-			htmlRaw, err := os.ReadFile(filepath.Join("demo", "preview.html"))
-			if err != nil {
-				t.Fatal(err)
-			}
-			if strings.Contains(string(htmlRaw), `data="`) {
-				t.Fatalf("preview should not embed unsafe slide path:\n%s", string(htmlRaw))
-			}
-		})
-	}
-}
-
-func TestWritePreviewWritesFailureArtifactsForDeckReadFailures(t *testing.T) {
-	initValidateTestRun(t)
-	if err := os.Remove(filepath.Join("demo", "outline", "deck.json")); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-
-	report, err := WritePreview("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "failed" {
-		t.Fatalf("Status = %q, want failed: %+v", report.Status, report)
-	}
-	if _, err := os.Stat(filepath.Join("demo", "preview.html")); err != nil {
-		t.Fatalf("missing preview.html for failed deck read: %v", err)
-	}
-	receipt := readPreviewReceipt(t)
-	if receipt.Status != "failed" || len(receipt.Slides) != 1 || receipt.Slides[0].Path != "outline/deck.json" {
-		t.Fatalf("preview receipt = %+v, want failed deck report", receipt)
-	}
-}
-
-func TestWritePreviewRejectsPreviewSymlink(t *testing.T) {
-	cwd := initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-	outside := filepath.Join(filepath.Dir(cwd), "outside-preview.html")
-	if err := os.WriteFile(outside, []byte("outside"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(filepath.Join("demo", "preview.html")); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "preview.html")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := WritePreview("demo"); err == nil {
-		t.Fatal("expected preview symlink write refusal")
-	}
-	raw, err := os.ReadFile(outside)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(raw) != "outside" {
-		t.Fatalf("outside preview overwritten: %q", string(raw))
-	}
-}
-
-func TestWritePreviewRejectsPreviewReceiptSymlink(t *testing.T) {
-	cwd := initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-	outside := filepath.Join(filepath.Dir(cwd), "outside-preview.json")
-	if err := os.WriteFile(outside, []byte("outside"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(filepath.Join("demo", "receipts", "preview.json")); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "receipts", "preview.json")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := WritePreview("demo"); err == nil {
-		t.Fatal("expected preview receipt symlink write refusal")
-	}
-	raw, err := os.ReadFile(outside)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(raw) != "outside" {
-		t.Fatalf("outside preview receipt overwritten: %q", string(raw))
-	}
-}
-
-func TestWritePreviewRejectsPreviewReceiptsDirectorySymlink(t *testing.T) {
-	cwd := initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-	if err := os.RemoveAll(filepath.Join("demo", "receipts")); err != nil {
-		t.Fatal(err)
-	}
-	outside := filepath.Join(filepath.Dir(cwd), "outside-preview-receipts")
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "receipts")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := WritePreview("demo"); err == nil {
-		t.Fatal("expected preview receipts directory symlink write refusal")
-	}
-	if _, err := os.Stat(filepath.Join(outside, "preview.json")); !os.IsNotExist(err) {
-		t.Fatalf("preview receipt should not be written outside run root, stat err=%v", err)
-	}
-}
-
-func readPreviewReceipt(t *testing.T) PreviewReport {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("demo", "receipts", "preview.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var receipt PreviewReport
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatal(err)
-	}
-	return receipt
-}
-
-func writeDeckAt(t *testing.T, path string, deck previewDeck) {
-	t.Helper()
-	raw, err := json.MarshalIndent(deck, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw = append(raw, '\n')
-	writeValidateTestFile(t, path, string(raw))
-}

internal/svglide/prompt.go

@@ -1,390 +0,0 @@
-package svglide
-
-type PromptFile struct {
-	Name    string
-	Content string
-}
-
-func DefaultPromptFiles() []PromptFile {
-	return []PromptFile{
-		{Name: "01_request.task.md", Content: `# request
-
-Inputs:
-- request/request.json
-- request/source_manifest.json
-
-Outputs:
-- request/request.json
-- request/source_manifest.json
-
-Receipt:
-- receipts/request.json
-
-Acceptance:
-- title/input 必须存在且与本地源一致。
-- source_manifest.sources 必须列出本地输入源路径和 type=local。
-
-Do not:
-- 不要联网发布或修改 slides 目录。
-`},
-		{Name: "02_research.task.md", Content: `# research
-
-Inputs:
-- request/request.json
-- request/source_manifest.json
-- local input source
-
-Outputs:
-- research/research_notes.md
-- research/sources.json
-
-Receipt:
-- receipts/research.json
-
-Acceptance:
-- 结论必须能追溯到本地输入源。
-- sources.json 必须保留来源路径和摘录用途。
-
-Do not:
-- 不要编造外部来源。
-`},
-		{Name: "03_design_brief.task.md", Content: `# design_brief
-
-Inputs:
-- request/request.json
-- research/research_notes.md
-
-Outputs:
-- brief/design_brief.json
-- brief/visual_system.json
-
-Receipt:
-- receipts/design_brief.json
-
-Acceptance:
-- design_brief.json 必须包含 narrative_spine/depth/tone。
-- visual_system.json 必须包含 color_system/typography/layout_language。
-
-Do not:
-- 不要提前生成最终 SVG。
-`},
-		{Name: "04_outline.task.md", Content: `# outline
-
-Inputs:
-- brief/design_brief.json
-- brief/visual_system.json
-
-Outputs:
-- outline/deck.json
-
-Receipt:
-- receipts/outline.json
-
-Acceptance:
-- 每页必须有 id/title/summary/role/key_message/path。
-- deck.slides 顺序就是最终页序。
-
-Do not:
-- 不要把正文长文塞进 outline。
-`},
-		{Name: "05_slide_content.task.md", Content: `# slide_content
-
-Inputs:
-- outline/deck.json
-- research/research_notes.md
-
-Outputs:
-- content/slide_content.md
-- content/slide_content.json
-
-Receipt:
-- receipts/slide_content.json
-
-Acceptance:
-- slide_content.json 必须按 deck.slides 的 id 对齐。
-- 每页内容必须支持对应 key_message。
-
-Do not:
-- 不要写最终 SVG。
-`},
-		{Name: "06_assets.task.md", Content: `# assets
-
-Inputs:
-- content/slide_content.json
-- brief/visual_system.json
-
-Outputs:
-- assets/assets_plan.json
-- assets/charts/*.svg when charts are required
-- assets/images/* when local images are required
-
-Receipt:
-- receipts/assets.json
-
-Acceptance:
-- assets_plan.json 必须说明每个资产的 id/type/path/usage。
-- 图表资产必须写入本地 assets/charts/*.svg。
-
-Do not:
-- 不要在 slides/*.svg 中引用远程 URL。
-`},
-		{Name: "07_svg_author.task.md", Content: `# svg_author
-
-Inputs:
-- outline/deck.json
-- content/slide_content.json
-- brief/visual_system.json
-- assets/assets_plan.json
-- assets/charts/*.svg
-- assets/images/*
-
-Outputs:
-- slides/*.svg
-
-Receipt:
-- receipts/svg_author.json
-
-Acceptance:
-- 每个 deck slide 的 path 必须对应一个 slides/*.svg。
-- 必须读取 deck、content、visual_system、assets 后再生成 SVG。
-- 必须遵守 AnyGen SVG protocol 基本点：纯 SVG、960x540 viewBox、文本可选中、图形语义清晰、无远程资源引用。
-
-Do not:
-- 禁止只写背景。
-- 不要把整页内容栅格化成单张图片。
-- 不要发布到 Feishu Slides。
-`},
-		{Name: "08_repair.task.md", Content: `# validate_preview_repair
-
-Inputs:
-- slides/*.svg
-
-Outputs:
-- receipts/lint.json
-- receipts/preview.json
-- repair_queue.md
-- preview.html
-
-Receipt:
-- receipts/validate_preview_repair.json
-
-Acceptance:
-- 先运行或触发本地 validate + preview，产出 receipts/lint.json、receipts/preview.json、repair_queue.md、preview.html。
-- 如果 repair_queue.md 有修复项，再基于 repair_queue.md 与 receipts/lint.json 修复 slides/*.svg。
-- 修复后再次确认 SVG 保持纯 SVG、可编辑、无远程资源引用。
-- 最后写 receipts/validate_preview_repair.json，记录 validate、preview、repair 的状态和产物路径。
-
-Do not:
-- 不要通过删除内容来绕过检查。
-- 不要跳过 lint/preview 直接写最终 receipt。
-`},
-	}
-}
-
-func DefaultSchemas() map[string]string {
-	return map[string]string{
-		"request.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["title", "input"],
-  "properties": {
-    "title": {"type": "string"},
-    "input": {"type": "string"},
-    "audience": {"type": "string"},
-    "delivery_mode": {"type": "string"},
-    "pages": {"type": "integer"}
-  }
-}
-`,
-		"source_manifest.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["sources"],
-  "properties": {
-    "sources": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["path", "type"],
-        "properties": {
-          "path": {"type": "string"},
-          "type": {"type": "string", "enum": ["local"]}
-        }
-      }
-    }
-  }
-}
-`,
-		"sources.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["sources"],
-  "properties": {
-    "sources": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["path", "excerpt", "usage"],
-        "properties": {
-          "path": {"type": "string"},
-          "excerpt": {"type": "string"},
-          "usage": {"type": "string"}
-        }
-      }
-    }
-  }
-}
-`,
-		"design_brief.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["narrative_spine", "depth", "tone"],
-  "properties": {
-    "narrative_spine": {"type": "string"},
-    "depth": {"type": "string"},
-    "tone": {"type": "string"}
-  }
-}
-`,
-		"visual_system.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["color_system", "typography", "layout_language"],
-  "properties": {
-    "color_system": {"type": "object"},
-    "typography": {"type": "object"},
-    "layout_language": {"type": "string"}
-  }
-}
-`,
-		"deck.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["title", "slides"],
-  "properties": {
-    "title": {"type": "string"},
-    "slides": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "title", "summary", "role", "key_message", "path"],
-        "properties": {
-          "id": {"type": "string"},
-          "title": {"type": "string"},
-          "summary": {"type": "string"},
-          "role": {"type": "string"},
-          "key_message": {"type": "string"},
-          "path": {"type": "string", "pattern": "^slides/[^/]+\\.svg$"}
-        }
-      }
-    }
-  }
-}
-`,
-		"slide_content.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["slides"],
-  "properties": {
-    "slides": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "content"],
-        "properties": {
-          "id": {"type": "string"},
-          "content": {"type": "string"},
-          "notes": {"type": "string"}
-        }
-      }
-    }
-  }
-}
-`,
-		"assets_plan.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["assets"],
-  "properties": {
-    "assets": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "type", "path", "usage"],
-        "properties": {
-          "id": {"type": "string"},
-          "type": {"type": "string"},
-          "path": {"type": "string"},
-          "usage": {"type": "string"}
-        }
-      }
-    }
-  }
-}
-`,
-		"receipt.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["stage", "status"],
-  "properties": {
-    "stage": {"type": "string"},
-    "status": {"type": "string"},
-    "message": {"type": "string"},
-    "artifacts": {"type": "array", "items": {"type": "string"}}
-  }
-}
-`,
-		"lint.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["status", "issues"],
-  "properties": {
-    "status": {"type": "string"},
-    "issues": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["path", "code", "message"],
-        "properties": {
-          "path": {"type": "string"},
-          "code": {"type": "string"},
-          "message": {"type": "string"},
-          "severity": {"type": "string"}
-        }
-      }
-    }
-  }
-}
-`,
-		"preview.schema.json": `{
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["status", "slides"],
-  "properties": {
-    "status": {"type": "string"},
-    "slides": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["path", "rendered"],
-        "properties": {
-          "path": {"type": "string"},
-          "rendered": {"type": "boolean"},
-          "message": {"type": "string"}
-        }
-      }
-    }
-  }
-}
-`,
-	}
-}

internal/svglide/receipt.go

@@ -1,153 +0,0 @@
-package svglide
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/fs"
-	"path/filepath"
-	"strings"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-type validationLintReceipt struct {
-	Status string            `json:"status"`
-	Issues []ValidationIssue `json:"issues"`
-}
-
-func writeValidationArtifacts(safeRoot string, report ValidationReport) error {
-	report = normalizeValidationReport(report)
-	lintPath, err := ensureRunFileTargetForWrite(safeRoot, "receipts/lint.json")
-	if err != nil {
-		return err
-	}
-	raw, err := json.MarshalIndent(validationLintReceipt{
-		Status: validationReceiptStatus(report),
-		Issues: report.Issues,
-	}, "", "  ")
-	if err != nil {
-		return err
-	}
-	raw = append(raw, '\n')
-	if err := validate.AtomicWrite(lintPath, raw, 0o644); err != nil {
-		return err
-	}
-	queuePath, err := ensureRunFileTargetForWrite(safeRoot, "repair_queue.md")
-	if err != nil {
-		return err
-	}
-	return validate.AtomicWrite(queuePath, []byte(renderRepairQueue(report)), 0o644)
-}
-
-func normalizeValidationReport(report ValidationReport) ValidationReport {
-	if report.Issues == nil {
-		report.Issues = []ValidationIssue{}
-	}
-	report.OK = len(report.Issues) == 0
-	for i := range report.Issues {
-		report.Issues[i].Path = strings.TrimSpace(report.Issues[i].Path)
-		if report.Issues[i].Path == "" {
-			report.Issues[i].Path = "(deck)"
-		}
-		report.Issues[i].Code = strings.TrimSpace(report.Issues[i].Code)
-		if report.Issues[i].Code == "" {
-			report.Issues[i].Code = "svglide.validation"
-		}
-		report.Issues[i].Severity = strings.TrimSpace(report.Issues[i].Severity)
-		if report.Issues[i].Severity == "" {
-			report.Issues[i].Severity = "error"
-		}
-	}
-	return report
-}
-
-func validationReceiptStatus(report ValidationReport) string {
-	if report.OK {
-		return "passed"
-	}
-	return "failed"
-}
-
-func renderRepairQueue(report ValidationReport) string {
-	if report.OK {
-		return "No repair needed.\n"
-	}
-	var b bytes.Buffer
-	b.WriteString("# SVGlide Repair Queue\n\n")
-	for _, issue := range report.Issues {
-		fmt.Fprintf(&b, "- `%s` [%s]: %s\n", issue.Path, issue.Code, issue.Message)
-	}
-	return b.String()
-}
-
-func ensureRunFileTargetForWrite(safeRoot string, rel string) (string, error) {
-	cleanRel := filepath.Clean(rel)
-	if cleanRel == "." {
-		return "", fmt.Errorf("run file path must not be root")
-	}
-	dirRel := filepath.Dir(cleanRel)
-	if _, err := ensureRunDirectoryForWrite(safeRoot, dirRel); err != nil {
-		return "", err
-	}
-	path, err := safeRunPath(safeRoot, cleanRel)
-	if err != nil {
-		return "", err
-	}
-	info, err := vfs.Lstat(path)
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			return path, nil
-		}
-		return "", err
-	}
-	if info.Mode()&fs.ModeSymlink != 0 {
-		return "", fmt.Errorf("run file path %q must not be a symlink", rel)
-	}
-	if !info.Mode().IsRegular() {
-		return "", fmt.Errorf("run file path %q must be a regular file", rel)
-	}
-	return path, nil
-}
-
-func ensureRunDirectoryForWrite(safeRoot string, rel string) (string, error) {
-	path, err := safeRunPath(safeRoot, rel)
-	if err != nil {
-		return "", err
-	}
-	cleanRel := filepath.Clean(rel)
-	if cleanRel == "." {
-		return path, nil
-	}
-	parts := strings.Split(cleanRel, string(filepath.Separator))
-	cur := safeRoot
-	for i, part := range parts {
-		if part == "" || part == "." {
-			continue
-		}
-		cur = filepath.Join(cur, part)
-		info, err := vfs.Lstat(cur)
-		if err != nil {
-			if !errors.Is(err, fs.ErrNotExist) {
-				return "", err
-			}
-			if err := vfs.Mkdir(cur, 0o755); err != nil {
-				info, err = vfs.Lstat(cur)
-				if err != nil {
-					return "", err
-				}
-			} else {
-				continue
-			}
-		}
-		if info.Mode()&fs.ModeSymlink != 0 {
-			return "", fmt.Errorf("run directory path %q must not contain symlink component %q", rel, filepath.Join(parts[:i+1]...))
-		}
-		if !info.IsDir() {
-			return "", fmt.Errorf("run directory path %q component %q is not a directory", rel, filepath.Join(parts[:i+1]...))
-		}
-	}
-	return path, nil
-}

internal/svglide/repair.go

@@ -1,132 +0,0 @@
-package svglide
-
-import (
-	"strings"
-)
-
-type RepairReport struct {
-	Status     string `json:"status"`
-	LintOK     bool   `json:"lint_ok"`
-	Preview    string `json:"preview"`
-	Reauthored bool   `json:"reauthored"`
-}
-
-func RepairRun(root string) (RepairReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return RepairReport{}, err
-	}
-
-	lint, validateErr := ValidateRun(root)
-	if validateErr != nil {
-		return RepairReport{}, validateErr
-	}
-
-	reauthored := false
-	if !lint.OK {
-		repairPaths, ok := authorRepairPaths(lint)
-		if ok {
-			if _, err := authorSlides(root, repairPaths); err != nil {
-				return RepairReport{}, err
-			}
-			reauthored = true
-			lint, validateErr = ValidateRun(root)
-		}
-		if validateErr != nil {
-			return RepairReport{}, validateErr
-		}
-	}
-
-	preview, err := WritePreview(root)
-	if err != nil {
-		return RepairReport{}, err
-	}
-
-	report := RepairReport{
-		Status:     "failed",
-		LintOK:     lint.OK,
-		Preview:    preview.Status,
-		Reauthored: reauthored,
-	}
-	if report.LintOK && report.Preview == "passed" {
-		report.Status = "passed"
-	}
-
-	previewPath := strings.TrimSpace(run.Artifacts.Preview)
-	if previewPath == "" {
-		previewPath = defaultPreviewPath
-	}
-	if err := writeStageReceipt(safeRoot, StageReceipt{
-		Stage:   StageValidatePreviewRepair,
-		Status:  report.Status,
-		Message: repairReceiptMessage(report),
-		Artifacts: []string{
-			"receipts/lint.json",
-			"receipts/preview.json",
-			"repair_queue.md",
-			previewPath,
-		},
-	}); err != nil {
-		return report, err
-	}
-
-	return report, nil
-}
-
-func canRepairByAuthoring(report ValidationReport) bool {
-	_, ok := authorRepairPaths(report)
-	return ok
-}
-
-func authorRepairPaths(report ValidationReport) (map[string]bool, bool) {
-	if report.OK || len(report.Issues) == 0 {
-		return nil, false
-	}
-	paths := make(map[string]bool)
-	for _, issue := range report.Issues {
-		path, ok := repairIssueAuthorPath(issue)
-		if !ok {
-			return nil, false
-		}
-		paths[path] = true
-	}
-	if len(paths) == 0 {
-		return nil, false
-	}
-	return paths, true
-}
-
-func canRepairIssueByAuthoring(issue ValidationIssue) bool {
-	_, ok := repairIssueAuthorPath(issue)
-	return ok
-}
-
-func repairIssueAuthorPath(issue ValidationIssue) (string, bool) {
-	path := strings.TrimSpace(issue.Path)
-	slidePath, err := previewSlideObjectPath(path)
-	if err != nil {
-		return "", false
-	}
-
-	switch strings.TrimSpace(issue.Code) {
-	case "svglide.path":
-		return slidePath, strings.Contains(issue.Message, "missing or not a regular file")
-	case "svglide.xml", "svglide.root", "svglide.slide_role", "svglide.viewbox", "svglide.visible_content":
-		return slidePath, true
-	default:
-		return "", false
-	}
-}
-
-func repairReceiptMessage(report RepairReport) string {
-	if report.Status == "passed" {
-		if report.Reauthored {
-			return "lint and preview passed after reauthoring"
-		}
-		return "lint and preview passed"
-	}
-	if report.Reauthored {
-		return "repair reauthored slides but lint or preview still failed"
-	}
-	return "lint or preview failed"
-}

internal/svglide/repair_test.go

@@ -1,175 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestRepairRunAuthorsMissingSlidesAndWritesFinalReceipt(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"}]}`,
-	)
-
-	report, err := RepairRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "passed" {
-		t.Fatalf("Status = %q, want passed: %+v", report.Status, report)
-	}
-	if !report.LintOK {
-		t.Fatalf("LintOK = false, want true: %+v", report)
-	}
-	if report.Preview != "passed" {
-		t.Fatalf("Preview = %q, want passed: %+v", report.Preview, report)
-	}
-	if !report.Reauthored {
-		t.Fatalf("Reauthored = false, want true: %+v", report)
-	}
-
-	for _, rel := range []string{
-		"slides/01.svg",
-		"preview.html",
-		"receipts/lint.json",
-		"receipts/preview.json",
-		"receipts/validate_preview_repair.json",
-	} {
-		if _, err := os.Stat(filepath.Join("demo", rel)); err != nil {
-			t.Fatalf("missing %s: %v", rel, err)
-		}
-	}
-
-	receipt := readRepairReceiptForTest(t)
-	if receipt["stage"] != StageValidatePreviewRepair {
-		t.Fatalf("receipt stage = %v, want %q", receipt["stage"], StageValidatePreviewRepair)
-	}
-	if receipt["status"] != "passed" {
-		t.Fatalf("receipt status = %v, want passed", receipt["status"])
-	}
-	if _, ok := receipt["artifacts"].([]any); !ok {
-		t.Fatalf("receipt artifacts = %T, want array", receipt["artifacts"])
-	}
-	if _, ok := receipt["updated_at"]; ok {
-		t.Fatalf("receipt contains updated_at, want StageReceipt-compatible schema: %+v", receipt)
-	}
-	if _, ok := receipt["generated_at"]; ok {
-		t.Fatalf("receipt contains generated_at, want StageReceipt-compatible schema: %+v", receipt)
-	}
-}
-
-func TestRepairRunOnlyReauthorsFailedSlidePaths(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"},{"id":"s2","title":"Second claim","summary":"Second summary","role":"content","key_message":"Second key message","path":"slides/02.svg"}]}`,
-	)
-	custom := `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><rect width="960" height="540" fill="#fff"/><text x="48" y="80">KEEP-CUSTOM-01</text></svg>`
-	mustWriteTestFile(t, "demo/slides/01.svg", custom)
-
-	report, err := RepairRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "passed" || !report.Reauthored || !report.LintOK || report.Preview != "passed" {
-		t.Fatalf("report = %+v, want passed reauthored repair", report)
-	}
-
-	raw, err := os.ReadFile(filepath.Join("demo", "slides", "01.svg"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(raw) != custom {
-		t.Fatalf("slides/01.svg was overwritten:\n%s", string(raw))
-	}
-	if _, err := os.Stat(filepath.Join("demo", "slides", "02.svg")); err != nil {
-		t.Fatalf("missing reauthored slides/02.svg: %v", err)
-	}
-
-	validation, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !validation.OK {
-		t.Fatalf("ValidateRun OK = false after repair: %+v", validation.Issues)
-	}
-}
-
-func TestRepairRunReauthorsBackgroundOnlySVG(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"}]}`,
-	)
-	mustWriteTestFile(t, "demo/slides/01.svg", backgroundOnlySVG())
-
-	report, err := RepairRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "passed" || !report.Reauthored || !report.LintOK || report.Preview != "passed" {
-		t.Fatalf("report = %+v, want passed reauthored repair", report)
-	}
-
-	validation, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !validation.OK {
-		t.Fatalf("ValidateRun OK = false after repair: %+v", validation.Issues)
-	}
-}
-
-func TestRepairRunDoesNotAuthorInvalidSlidePath(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/../01.svg"}]}`,
-	)
-
-	report, err := RepairRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Status != "failed" {
-		t.Fatalf("Status = %q, want failed: %+v", report.Status, report)
-	}
-	if report.Reauthored {
-		t.Fatalf("Reauthored = true, want false for invalid path: %+v", report)
-	}
-	if _, err := os.Stat(filepath.Join("demo", "receipts", "svg_author.json")); !os.IsNotExist(err) {
-		t.Fatalf("svg_author receipt exists or stat failed, want no authoring: %v", err)
-	}
-}
-
-func TestRepairRunTreatsValidationArtifactWriteErrorAsFatal(t *testing.T) {
-	initAuthorDemoRun(t,
-		`{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`,
-		`{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/01.svg"}]}`,
-	)
-	if err := os.Remove(filepath.Join("demo", "repair_queue.md")); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if err := os.Mkdir(filepath.Join("demo", "repair_queue.md"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := RepairRun("demo"); err == nil {
-		t.Fatal("expected repair to return validation artifact write error")
-	}
-	if _, err := os.Stat(filepath.Join("demo", "receipts", "validate_preview_repair.json")); !os.IsNotExist(err) {
-		t.Fatalf("final repair receipt exists or stat failed, want no misleading final receipt: %v", err)
-	}
-}
-
-func readRepairReceiptForTest(t *testing.T) map[string]any {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("demo", "receipts", "validate_preview_repair.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var receipt map[string]any
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatal(err)
-	}
-	return receipt
-}

internal/svglide/run.go

@@ -1,120 +0,0 @@
-package svglide
-
-import "time"
-
-const (
-	StageRequest               = "request"
-	StageResearch              = "research"
-	StageDesignBrief           = "design_brief"
-	StageOutline               = "outline"
-	StageSlideContent          = "slide_content"
-	StageAssets                = "assets"
-	StageSVGAuthor             = "svg_author"
-	StageValidatePreviewRepair = "validate_preview_repair"
-
-	StatusPending     = "pending"
-	StatusReady       = "ready"
-	StatusInProgress  = "in_progress"
-	StatusDone        = "done"
-	StatusFailed      = "failed"
-	StatusBlocked     = "blocked"
-	StatusNeedsRepair = "needs_repair"
-)
-
-type Run struct {
-	Version      int           `json:"version"`
-	Runtime      string        `json:"runtime"`
-	Command      string        `json:"command"`
-	Title        string        `json:"title"`
-	Input        string        `json:"input"`
-	Audience     string        `json:"audience,omitempty"`
-	DeliveryMode string        `json:"delivery_mode,omitempty"`
-	Pages        int           `json:"pages,omitempty"`
-	Out          string        `json:"out"`
-	CreatedAt    string        `json:"created_at"`
-	UpdatedAt    string        `json:"updated_at"`
-	CurrentStage string        `json:"current_stage"`
-	Stages       []Stage       `json:"stages"`
-	Artifacts    ArtifactPaths `json:"artifacts"`
-	Policy       Policy        `json:"policy"`
-}
-
-type Stage struct {
-	Name    string   `json:"name"`
-	Status  string   `json:"status"`
-	Inputs  []string `json:"inputs"`
-	Outputs []string `json:"outputs"`
-	Receipt string   `json:"receipt"`
-}
-
-type ArtifactPaths struct {
-	Deck        string `json:"deck"`
-	SlidesDir   string `json:"slides_dir"`
-	Preview     string `json:"preview"`
-	RepairQueue string `json:"repair_queue"`
-}
-
-type Policy struct {
-	PublishEnabled         bool `json:"publish_enabled"`
-	NetworkByCodex         bool `json:"network_by_codex"`
-	ImageGenerationByCodex bool `json:"image_generation_by_codex"`
-	Overwrite              bool `json:"overwrite"`
-}
-
-type NewRunConfig struct {
-	Title        string
-	Input        string
-	Audience     string
-	DeliveryMode string
-	Pages        int
-	Out          string
-	Now          time.Time
-}
-
-func NewRun(cfg NewRunConfig) Run {
-	now := cfg.Now
-	if now.IsZero() {
-		now = time.Now()
-	}
-	ts := now.Format(time.RFC3339)
-	return Run{
-		Version:      1,
-		Runtime:      "codex",
-		Command:      "slides +create-svglide",
-		Title:        cfg.Title,
-		Input:        cfg.Input,
-		Audience:     cfg.Audience,
-		DeliveryMode: cfg.DeliveryMode,
-		Pages:        cfg.Pages,
-		Out:          cfg.Out,
-		CreatedAt:    ts,
-		UpdatedAt:    ts,
-		CurrentStage: StageRequest,
-		Stages:       DefaultStages(),
-		Artifacts: ArtifactPaths{
-			Deck:        "outline/deck.json",
-			SlidesDir:   "slides",
-			Preview:     "preview.html",
-			RepairQueue: "repair_queue.md",
-		},
-		Policy: Policy{
-			PublishEnabled:         false,
-			NetworkByCodex:         true,
-			ImageGenerationByCodex: true,
-			Overwrite:              false,
-		},
-	}
-}
-
-func DefaultStages() []Stage {
-	return []Stage{
-		{Name: StageRequest, Status: StatusPending, Inputs: []string{}, Outputs: []string{"request/request.json", "request/source_manifest.json"}, Receipt: "receipts/request.json"},
-		{Name: StageResearch, Status: StatusPending, Inputs: []string{"request/request.json", "request/source_manifest.json"}, Outputs: []string{"research/research_notes.md", "research/sources.json"}, Receipt: "receipts/research.json"},
-		{Name: StageDesignBrief, Status: StatusPending, Inputs: []string{"request/request.json", "research/research_notes.md"}, Outputs: []string{"brief/design_brief.json", "brief/visual_system.json"}, Receipt: "receipts/design_brief.json"},
-		{Name: StageOutline, Status: StatusPending, Inputs: []string{"brief/design_brief.json", "brief/visual_system.json"}, Outputs: []string{"outline/deck.json"}, Receipt: "receipts/outline.json"},
-		{Name: StageSlideContent, Status: StatusPending, Inputs: []string{"outline/deck.json", "research/research_notes.md"}, Outputs: []string{"content/slide_content.md", "content/slide_content.json"}, Receipt: "receipts/slide_content.json"},
-		{Name: StageAssets, Status: StatusPending, Inputs: []string{"content/slide_content.json", "brief/visual_system.json"}, Outputs: []string{"assets/assets_plan.json"}, Receipt: "receipts/assets.json"},
-		{Name: StageSVGAuthor, Status: StatusPending, Inputs: []string{"outline/deck.json", "content/slide_content.json", "brief/visual_system.json", "assets/assets_plan.json"}, Outputs: []string{"slides/*.svg"}, Receipt: "receipts/svg_author.json"},
-		{Name: StageValidatePreviewRepair, Status: StatusPending, Inputs: []string{"slides/*.svg"}, Outputs: []string{"receipts/lint.json", "receipts/preview.json", "repair_queue.md", "preview.html"}, Receipt: "receipts/validate_preview_repair.json"},
-	}
-}

internal/svglide/run_test.go

@@ -1,154 +0,0 @@
-package svglide
-
-import (
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestDefaultStagesAreOrdered(t *testing.T) {
-	stages := DefaultStages()
-	want := []string{
-		StageRequest,
-		StageResearch,
-		StageDesignBrief,
-		StageOutline,
-		StageSlideContent,
-		StageAssets,
-		StageSVGAuthor,
-		StageValidatePreviewRepair,
-	}
-	if len(stages) != len(want) {
-		t.Fatalf("stage count = %d, want %d", len(stages), len(want))
-	}
-	for i, stage := range stages {
-		if stage.Name != want[i] {
-			t.Fatalf("stage[%d] = %q, want %q", i, stage.Name, want[i])
-		}
-		if stage.Status != StatusPending {
-			t.Fatalf("stage[%d].Status = %q, want %q", i, stage.Status, StatusPending)
-		}
-		if stage.Inputs == nil {
-			t.Fatalf("stage[%d].Inputs = nil, want stable empty array", i)
-		}
-		if stage.Outputs == nil {
-			t.Fatalf("stage[%d].Outputs = nil, want stable empty array", i)
-		}
-		if stage.Receipt == "" {
-			t.Fatalf("stage[%d] missing receipt path", i)
-		}
-	}
-}
-
-func TestDefaultStagesRequireGeneratedSlideSVGs(t *testing.T) {
-	stages := DefaultStages()
-	svgAuthor := mustStage(t, stages, StageSVGAuthor)
-	if !reflect.DeepEqual(svgAuthor.Outputs, []string{"slides/*.svg"}) {
-		t.Fatalf("svg_author Outputs = %v, want slides/*.svg", svgAuthor.Outputs)
-	}
-	repair := mustStage(t, stages, StageValidatePreviewRepair)
-	if !reflect.DeepEqual(repair.Inputs, []string{"slides/*.svg"}) {
-		t.Fatalf("validate_preview_repair Inputs = %v, want slides/*.svg", repair.Inputs)
-	}
-}
-
-func TestDefaultStagesResearchInputsMatchPromptContract(t *testing.T) {
-	stages := DefaultStages()
-	research := mustStage(t, stages, StageResearch)
-	want := []string{"request/request.json", "request/source_manifest.json"}
-	if !reflect.DeepEqual(research.Inputs, want) {
-		t.Fatalf("research Inputs = %v, want %v", research.Inputs, want)
-	}
-}
-
-func TestDefaultStagesOutlineInputsMatchPromptContract(t *testing.T) {
-	stages := DefaultStages()
-	outline := mustStage(t, stages, StageOutline)
-	want := []string{"brief/design_brief.json", "brief/visual_system.json"}
-	if !reflect.DeepEqual(outline.Inputs, want) {
-		t.Fatalf("outline Inputs = %v, want %v", outline.Inputs, want)
-	}
-}
-
-func TestNewRunDefaultsToCodexRuntime(t *testing.T) {
-	now := time.Date(2026, 7, 2, 15, 4, 5, 0, time.UTC)
-	run := NewRun(NewRunConfig{
-		Title:        "Demo",
-		Input:        "source.md",
-		Audience:     "产品和工程负责人",
-		DeliveryMode: "self_read",
-		Pages:        8,
-		Out:          ".lark-slides/svglide-runs/demo",
-		Now:          now,
-	})
-	if run.Version != 1 {
-		t.Fatalf("Version = %d, want 1", run.Version)
-	}
-	if run.Runtime != "codex" {
-		t.Fatalf("Runtime = %q, want codex", run.Runtime)
-	}
-	if run.Command != "slides +create-svglide" {
-		t.Fatalf("Command = %q, want slides +create-svglide", run.Command)
-	}
-	if run.Title != "Demo" {
-		t.Fatalf("Title = %q, want Demo", run.Title)
-	}
-	if run.Input != "source.md" {
-		t.Fatalf("Input = %q, want source.md", run.Input)
-	}
-	if run.Audience != "产品和工程负责人" {
-		t.Fatalf("Audience = %q, want 产品和工程负责人", run.Audience)
-	}
-	if run.DeliveryMode != "self_read" {
-		t.Fatalf("DeliveryMode = %q, want self_read", run.DeliveryMode)
-	}
-	if run.Pages != 8 {
-		t.Fatalf("Pages = %d, want 8", run.Pages)
-	}
-	if run.Out != ".lark-slides/svglide-runs/demo" {
-		t.Fatalf("Out = %q, want .lark-slides/svglide-runs/demo", run.Out)
-	}
-	wantTS := now.Format(time.RFC3339)
-	if run.CreatedAt != wantTS {
-		t.Fatalf("CreatedAt = %q, want %q", run.CreatedAt, wantTS)
-	}
-	if run.UpdatedAt != wantTS {
-		t.Fatalf("UpdatedAt = %q, want %q", run.UpdatedAt, wantTS)
-	}
-	if run.CurrentStage != StageRequest {
-		t.Fatalf("CurrentStage = %q, want %q", run.CurrentStage, StageRequest)
-	}
-	wantArtifacts := ArtifactPaths{
-		Deck:        "outline/deck.json",
-		SlidesDir:   "slides",
-		Preview:     "preview.html",
-		RepairQueue: "repair_queue.md",
-	}
-	if run.Artifacts != wantArtifacts {
-		t.Fatalf("Artifacts = %+v, want %+v", run.Artifacts, wantArtifacts)
-	}
-	wantStages := DefaultStages()
-	if !reflect.DeepEqual(run.Stages, wantStages) {
-		t.Fatalf("Stages = %+v, want %+v", run.Stages, wantStages)
-	}
-	wantPolicy := Policy{
-		PublishEnabled:         false,
-		NetworkByCodex:         true,
-		ImageGenerationByCodex: true,
-		Overwrite:              false,
-	}
-	if run.Policy != wantPolicy {
-		t.Fatalf("Policy = %+v, want %+v", run.Policy, wantPolicy)
-	}
-}
-
-func mustStage(t *testing.T, stages []Stage, name string) Stage {
-	t.Helper()
-	for _, stage := range stages {
-		if stage.Name == name {
-			return stage
-		}
-	}
-	t.Fatalf("missing stage %q", name)
-	return Stage{}
-}

internal/svglide/schema.go

@@ -1,303 +0,0 @@
-package svglide
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math/big"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-type liteJSONSchema struct {
-	Type                 string                    `json:"type"`
-	Required             []string                  `json:"required"`
-	AdditionalProperties *bool                     `json:"additionalProperties"`
-	Properties           map[string]liteJSONSchema `json:"properties"`
-	Items                *liteJSONSchema           `json:"items"`
-	MinItems             *int                      `json:"minItems"`
-	Enum                 []string                  `json:"enum"`
-	Pattern              string                    `json:"pattern"`
-}
-
-var stageOutputSchemaPaths = map[string]string{
-	"request/request.json":         "schemas/request.schema.json",
-	"request/source_manifest.json": "schemas/source_manifest.schema.json",
-	"research/sources.json":        "schemas/sources.schema.json",
-	"brief/design_brief.json":      "schemas/design_brief.schema.json",
-	"brief/visual_system.json":     "schemas/visual_system.schema.json",
-	"outline/deck.json":            "schemas/deck.schema.json",
-	"content/slide_content.json":   "schemas/slide_content.schema.json",
-	"assets/assets_plan.json":      "schemas/assets_plan.schema.json",
-	"receipts/lint.json":           "schemas/lint.schema.json",
-	"receipts/preview.json":        "schemas/preview.schema.json",
-}
-
-func ValidateStageOutputs(root string) error {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return err
-	}
-	stage, err := currentStage(run)
-	if err != nil {
-		return err
-	}
-	for _, output := range stage.Outputs {
-		if hasGlobMeta(output) || strings.ToLower(filepath.Ext(output)) != ".json" {
-			continue
-		}
-		schemaPath, ok := stageOutputSchemaPaths[output]
-		if !ok {
-			continue
-		}
-		if err := validateStageOutputSchema(safeRoot, output, schemaPath); err != nil {
-			return err
-		}
-		if output == "outline/deck.json" {
-			if err := validateDeckSlideOutputPaths(safeRoot, output); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func validateDeckSlideOutputPaths(safeRoot string, artifactPath string) error {
-	raw, err := readRunRegularArtifact(safeRoot, artifactPath)
-	if err != nil {
-		return fmt.Errorf("%s: read artifact: %w", artifactPath, err)
-	}
-	var deck struct {
-		Slides []struct {
-			Path string `json:"path"`
-		} `json:"slides"`
-	}
-	if err := json.Unmarshal(raw, &deck); err != nil {
-		return fmt.Errorf("%s: invalid JSON: %w", artifactPath, err)
-	}
-	for i, slide := range deck.Slides {
-		if _, err := previewSlideObjectPath(slide.Path); err != nil {
-			return fmt.Errorf("%s: field slides[%d].path: %w", artifactPath, i, err)
-		}
-	}
-	return nil
-}
-
-func validateStageOutputSchema(safeRoot, artifactPath, schemaPath string) error {
-	artifactRaw, err := readRunRegularArtifact(safeRoot, artifactPath)
-	if err != nil {
-		return fmt.Errorf("%s: read artifact: %w", artifactPath, err)
-	}
-	schemaRaw, err := readRunRegularArtifact(safeRoot, schemaPath)
-	if err != nil {
-		return fmt.Errorf("%s: read schema %s: %w", artifactPath, schemaPath, err)
-	}
-	schema, err := decodeLiteJSONSchema(schemaRaw)
-	if err != nil {
-		return fmt.Errorf("%s: schema %s: %w", artifactPath, schemaPath, err)
-	}
-	value, err := decodeJSONValue(artifactRaw)
-	if err != nil {
-		return fmt.Errorf("%s: invalid JSON: %w", artifactPath, err)
-	}
-	if err := validateJSONValue(schema, value, ""); err != nil {
-		return fmt.Errorf("%s: %w", artifactPath, err)
-	}
-	return nil
-}
-
-func decodeLiteJSONSchema(raw []byte) (liteJSONSchema, error) {
-	var schema liteJSONSchema
-	decoder := json.NewDecoder(bytes.NewReader(raw))
-	if err := decoder.Decode(&schema); err != nil {
-		return liteJSONSchema{}, fmt.Errorf("invalid JSON: %w", err)
-	}
-	if err := rejectTrailingJSON(decoder); err != nil {
-		return liteJSONSchema{}, err
-	}
-	return schema, nil
-}
-
-func decodeJSONValue(raw []byte) (any, error) {
-	decoder := json.NewDecoder(bytes.NewReader(raw))
-	decoder.UseNumber()
-	var value any
-	if err := decoder.Decode(&value); err != nil {
-		return nil, err
-	}
-	if err := rejectTrailingJSON(decoder); err != nil {
-		return nil, err
-	}
-	return value, nil
-}
-
-func rejectTrailingJSON(decoder *json.Decoder) error {
-	var extra any
-	if err := decoder.Decode(&extra); err != io.EOF {
-		if err == nil {
-			return fmt.Errorf("contains trailing JSON value")
-		}
-		return err
-	}
-	return nil
-}
-
-func validateJSONValue(schema liteJSONSchema, value any, fieldPath string) error {
-	switch schema.Type {
-	case "":
-		return nil
-	case "object":
-		return validateJSONObject(schema, value, fieldPath)
-	case "array":
-		return validateJSONArray(schema, value, fieldPath)
-	case "string":
-		return validateJSONString(schema, value, fieldPath)
-	case "integer":
-		if !isJSONInteger(value) {
-			return fmt.Errorf("field %s expected integer, got %s", displayFieldPath(fieldPath), jsonValueType(value))
-		}
-		return nil
-	case "boolean":
-		if _, ok := value.(bool); !ok {
-			return fmt.Errorf("field %s expected boolean, got %s", displayFieldPath(fieldPath), jsonValueType(value))
-		}
-		return nil
-	default:
-		return fmt.Errorf("field %s uses unsupported schema type %q", displayFieldPath(fieldPath), schema.Type)
-	}
-}
-
-func validateJSONObject(schema liteJSONSchema, value any, fieldPath string) error {
-	object, ok := value.(map[string]any)
-	if !ok {
-		return fmt.Errorf("field %s expected object, got %s", displayFieldPath(fieldPath), jsonValueType(value))
-	}
-	for _, required := range schema.Required {
-		if _, ok := object[required]; !ok {
-			return fmt.Errorf("field %s is required", joinFieldPath(fieldPath, required))
-		}
-	}
-	if schema.AdditionalProperties != nil && !*schema.AdditionalProperties {
-		for name := range object {
-			if _, ok := schema.Properties[name]; !ok {
-				return fmt.Errorf("field %s is not allowed by additionalProperties:false", joinFieldPath(fieldPath, name))
-			}
-		}
-	}
-	for name, propertySchema := range schema.Properties {
-		child, ok := object[name]
-		if !ok {
-			continue
-		}
-		if err := validateJSONValue(propertySchema, child, joinFieldPath(fieldPath, name)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func validateJSONArray(schema liteJSONSchema, value any, fieldPath string) error {
-	array, ok := value.([]any)
-	if !ok {
-		return fmt.Errorf("field %s expected array, got %s", displayFieldPath(fieldPath), jsonValueType(value))
-	}
-	if schema.MinItems != nil && len(array) < *schema.MinItems {
-		return fmt.Errorf("field %s has %d items, want minItems %d", displayFieldPath(fieldPath), len(array), *schema.MinItems)
-	}
-	if schema.Items == nil {
-		return nil
-	}
-	for i, item := range array {
-		if err := validateJSONValue(*schema.Items, item, joinArrayFieldPath(fieldPath, i)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func validateJSONString(schema liteJSONSchema, value any, fieldPath string) error {
-	text, ok := value.(string)
-	if !ok {
-		return fmt.Errorf("field %s expected string, got %s", displayFieldPath(fieldPath), jsonValueType(value))
-	}
-	if len(schema.Enum) > 0 {
-		for _, allowed := range schema.Enum {
-			if text == allowed {
-				return nil
-			}
-		}
-		return fmt.Errorf("field %s value %q is not in enum %v", displayFieldPath(fieldPath), text, schema.Enum)
-	}
-	if schema.Pattern != "" {
-		matched, err := regexp.MatchString(schema.Pattern, text)
-		if err != nil {
-			return fmt.Errorf("field %s has invalid pattern %q: %w", displayFieldPath(fieldPath), schema.Pattern, err)
-		}
-		if !matched {
-			return fmt.Errorf("field %s value %q does not match pattern %q", displayFieldPath(fieldPath), text, schema.Pattern)
-		}
-	}
-	return nil
-}
-
-func isJSONInteger(value any) bool {
-	switch typed := value.(type) {
-	case json.Number:
-		return isCanonicalJSONInteger(typed.String())
-	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
-		return true
-	default:
-		return false
-	}
-}
-
-func isCanonicalJSONInteger(value string) bool {
-	if value == "" || strings.ContainsAny(value, ".eE") {
-		return false
-	}
-	var parsed big.Int
-	_, ok := parsed.SetString(value, 10)
-	return ok
-}
-
-func jsonValueType(value any) string {
-	switch value.(type) {
-	case nil:
-		return "null"
-	case map[string]any:
-		return "object"
-	case []any:
-		return "array"
-	case string:
-		return "string"
-	case json.Number, float64:
-		return "number"
-	case bool:
-		return "boolean"
-	default:
-		return fmt.Sprintf("%T", value)
-	}
-}
-
-func joinFieldPath(parent, name string) string {
-	if parent == "" {
-		return name
-	}
-	return parent + "." + name
-}
-
-func joinArrayFieldPath(parent string, index int) string {
-	if parent == "" {
-		return fmt.Sprintf("[%d]", index)
-	}
-	return fmt.Sprintf("%s[%d]", parent, index)
-}
-
-func displayFieldPath(path string) string {
-	if path == "" {
-		return "$"
-	}
-	return path
-}

internal/svglide/schema_test.go

@@ -1,159 +0,0 @@
-package svglide
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestValidateStageOutputsRejectsMissingRequiredField(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.WriteFile(filepath.Join("demo", "request", "request.json"), []byte(`{"title":"Demo"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	err := ValidateStageOutputs("demo")
-	if err == nil {
-		t.Fatal("expected schema validation error")
-	}
-	if !strings.Contains(err.Error(), "request/request.json") || !strings.Contains(err.Error(), "input") {
-		t.Fatalf("error = %v, want path and missing field", err)
-	}
-}
-
-func TestValidateStageOutputsAcceptsCurrentRequestArtifacts(t *testing.T) {
-	initStatusTestRun(t)
-
-	if err := ValidateStageOutputs("demo"); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestValidateStageOutputsRejectsDeckSlidePathsThatPreviewRejects(t *testing.T) {
-	for _, path := range []string{"slides/a%20.svg", "slides/.hidden.svg", "slides/a..b.svg", "slides/a:b.svg"} {
-		t.Run(path, func(t *testing.T) {
-			initStatusTestRun(t)
-			setCurrentStageForStatusTest(t, StageOutline)
-			mustWriteTestFile(t, "demo/outline/deck.json", `{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"`+path+`"}]}`)
-
-			err := ValidateStageOutputs("demo")
-			if err == nil {
-				t.Fatal("expected deck slide path validation error")
-			}
-			if !strings.Contains(err.Error(), "outline/deck.json") || !strings.Contains(err.Error(), "slides[0].path") {
-				t.Fatalf("error = %v, want deck path context", err)
-			}
-		})
-	}
-}
-
-func TestCompleteCurrentStageRejectsInvalidDeckSlidePath(t *testing.T) {
-	initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageOutline)
-	mustWriteTestFile(t, "demo/outline/deck.json", `{"title":"Demo Deck","slides":[{"id":"s1","title":"First claim","summary":"First summary","role":"cover","key_message":"First key message","path":"slides/a%20.svg"}]}`)
-
-	_, err := CompleteCurrentStage("demo")
-	if err == nil {
-		t.Fatal("expected deck slide path validation error")
-	}
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageOutline {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageOutline)
-	}
-	if got := stageStatus(t, run, StageOutline); got == StatusDone {
-		t.Fatalf("outline stage status = %q, want not %q", got, StatusDone)
-	}
-	if _, statErr := os.Stat(filepath.Join("demo", "receipts", "outline.json")); !os.IsNotExist(statErr) {
-		t.Fatalf("outline receipt should not be written, stat err = %v", statErr)
-	}
-}
-
-func TestValidateStageOutputsRejectsInvalidValidatePreviewRepairReceipts(t *testing.T) {
-	tests := []struct {
-		name  string
-		setup func(t *testing.T)
-		path  string
-	}{
-		{
-			name: "lint",
-			setup: func(t *testing.T) {
-				t.Helper()
-				if err := os.WriteFile(filepath.Join("demo", "receipts", "lint.json"), []byte(`{"status":"failed"}`), 0o644); err != nil {
-					t.Fatal(err)
-				}
-			},
-			path: "receipts/lint.json",
-		},
-		{
-			name: "preview",
-			setup: func(t *testing.T) {
-				t.Helper()
-				if err := os.WriteFile(filepath.Join("demo", "receipts", "lint.json"), []byte(`{"status":"passed","issues":[]}`), 0o644); err != nil {
-					t.Fatal(err)
-				}
-				if err := os.WriteFile(filepath.Join("demo", "receipts", "preview.json"), []byte(`{"status":"passed","slides":[{"path":"slides/01.svg","rendered":"yes"}]}`), 0o644); err != nil {
-					t.Fatal(err)
-				}
-			},
-			path: "receipts/preview.json",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initStatusTestRun(t)
-			setCurrentStageForStatusTest(t, StageValidatePreviewRepair)
-			tt.setup(t)
-
-			err := ValidateStageOutputs("demo")
-			if err == nil {
-				t.Fatal("expected schema validation error")
-			}
-			if !strings.Contains(err.Error(), tt.path) {
-				t.Fatalf("error = %v, want path %s", err, tt.path)
-			}
-		})
-	}
-}
-
-func TestValidateStageOutputsRejectsNonCanonicalIntegers(t *testing.T) {
-	for _, pages := range []string{"8.0", "8e0", "0.99999999999999999"} {
-		t.Run(pages, func(t *testing.T) {
-			initStatusTestRun(t)
-			raw := `{"title":"Demo","input":"source.md","pages":` + pages + `}`
-			if err := os.WriteFile(filepath.Join("demo", "request", "request.json"), []byte(raw), 0o644); err != nil {
-				t.Fatal(err)
-			}
-
-			err := ValidateStageOutputs("demo")
-			if err == nil {
-				t.Fatal("expected schema validation error")
-			}
-			if !strings.Contains(err.Error(), "request/request.json") || !strings.Contains(err.Error(), "pages") {
-				t.Fatalf("error = %v, want path and pages field", err)
-			}
-		})
-	}
-}
-
-func TestCompleteCurrentStageRejectsInvalidCurrentStageOutputSchema(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.WriteFile(filepath.Join("demo", "request", "source_manifest.json"), []byte(`{"sources":[{"path":"source.md","type":"remote"}]}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := CompleteCurrentStage("demo")
-	if err == nil {
-		t.Fatal("expected schema validation error")
-	}
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageRequest {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageRequest)
-	}
-	if got := stageStatus(t, run, StageRequest); got == StatusDone {
-		t.Fatalf("request stage status = %q, want not %q", got, StatusDone)
-	}
-	if _, statErr := os.Stat(filepath.Join("demo", "receipts", "request.json")); !os.IsNotExist(statErr) {
-		t.Fatalf("receipt should not be written, stat err = %v", statErr)
-	}
-}

internal/svglide/stage.go

@@ -1,120 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"fmt"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-type StageReceipt struct {
-	Stage     string   `json:"stage"`
-	Status    string   `json:"status"`
-	Message   string   `json:"message,omitempty"`
-	Artifacts []string `json:"artifacts,omitempty"`
-}
-
-func CompleteCurrentStage(root string) (StatusReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	index, stage, err := currentStageWithIndex(run)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	missingOutputs, err := missingRunPaths(safeRoot, stage.Outputs)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	if len(missingOutputs) > 0 {
-		return StatusReport{}, fmt.Errorf("current stage %q missing outputs: %s", stage.Name, strings.Join(missingOutputs, ", "))
-	}
-
-	if err := ValidateStageOutputs(root); err != nil {
-		return StatusReport{}, err
-	}
-	if stage.Name == StageValidatePreviewRepair {
-		if err := validateFinalStageReceiptsPassed(safeRoot); err != nil {
-			return StatusReport{}, err
-		}
-	}
-
-	if err := writeStageReceipt(safeRoot, StageReceipt{
-		Stage:     stage.Name,
-		Status:    StatusDone,
-		Artifacts: stage.Outputs,
-	}); err != nil {
-		return StatusReport{}, err
-	}
-
-	run.Stages[index].Status = StatusDone
-	if index < len(run.Stages)-1 {
-		nextStage := &run.Stages[index+1]
-		run.CurrentStage = nextStage.Name
-		if nextStage.Status == "" {
-			nextStage.Status = StatusPending
-		}
-	} else {
-		run.CurrentStage = stage.Name
-	}
-	run.UpdatedAt = time.Now().Format(time.RFC3339)
-
-	if err := writeRunFile(safeRoot, run); err != nil {
-		return StatusReport{}, err
-	}
-	return InspectStatus(root)
-}
-
-type stageStatusReceipt struct {
-	Status string `json:"status"`
-}
-
-func validateFinalStageReceiptsPassed(safeRoot string) error {
-	for _, path := range []string{"receipts/lint.json", "receipts/preview.json"} {
-		raw, err := readRunRegularArtifact(safeRoot, path)
-		if err != nil {
-			return fmt.Errorf("%s: read receipt: %w", path, err)
-		}
-		var receipt stageStatusReceipt
-		if err := json.Unmarshal(raw, &receipt); err != nil {
-			return fmt.Errorf("%s: invalid JSON: %w", path, err)
-		}
-		if receipt.Status != "passed" {
-			return fmt.Errorf("%s: status is %q, want passed", path, receipt.Status)
-		}
-	}
-	return nil
-}
-
-func currentStageWithIndex(run Run) (int, Stage, error) {
-	for i, stage := range run.Stages {
-		if stage.Name == run.CurrentStage {
-			return i, stage, nil
-		}
-	}
-	return -1, Stage{}, fmt.Errorf("current stage %q not found in run", run.CurrentStage)
-}
-
-func writeRunFile(safeRoot string, run Run) error {
-	target, err := ensureRunFileTargetForWrite(safeRoot, "run.json")
-	if err != nil {
-		return err
-	}
-	return writeJSON(target, run)
-}
-
-func writeStageReceipt(safeRoot string, receipt StageReceipt) error {
-	if strings.TrimSpace(receipt.Stage) == "" {
-		return fmt.Errorf("stage receipt stage must not be empty")
-	}
-	if strings.ContainsAny(receipt.Stage, `/\`) || receipt.Stage == "." || receipt.Stage == ".." {
-		return fmt.Errorf("stage receipt stage %q must be a file name", receipt.Stage)
-	}
-	target, err := ensureRunFileTargetForWrite(safeRoot, filepath.Join("receipts", receipt.Stage+".json"))
-	if err != nil {
-		return err
-	}
-	return writeJSON(target, receipt)
-}

internal/svglide/stage_test.go

@@ -1,116 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestCompleteCurrentStageAdvancesToNextStage(t *testing.T) {
-	initStatusTestRun(t)
-
-	status, err := CompleteCurrentStage("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if status.CurrentStage != StageResearch {
-		t.Fatalf("CurrentStage = %q, want %q", status.CurrentStage, StageResearch)
-	}
-
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageResearch {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageResearch)
-	}
-	if got := stageStatus(t, run, StageRequest); got != StatusDone {
-		t.Fatalf("request stage status = %q, want %q", got, StatusDone)
-	}
-	if got := stageStatus(t, run, StageResearch); got != StatusPending {
-		t.Fatalf("research stage status = %q, want %q", got, StatusPending)
-	}
-
-	raw, err := os.ReadFile(filepath.Join("demo", "receipts", "request.json"))
-	if err != nil {
-		t.Fatalf("missing request receipt: %v", err)
-	}
-	var receipt StageReceipt
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatalf("invalid request receipt: %v", err)
-	}
-	if receipt.Stage != StageRequest || receipt.Status != StatusDone {
-		t.Fatalf("receipt = %+v, want request done", receipt)
-	}
-}
-
-func TestCompleteCurrentStageRejectsMissingOutput(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.Remove(filepath.Join("demo", "request", "source_manifest.json")); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := CompleteCurrentStage("demo")
-	if err == nil {
-		t.Fatal("expected missing output error")
-	}
-
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageRequest {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageRequest)
-	}
-}
-
-func TestCompleteCurrentStageDoesNotAdvanceRunWhenReceiptWriteFails(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.Mkdir(filepath.Join("demo", "receipts", "request.json"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := CompleteCurrentStage("demo")
-	if err == nil {
-		t.Fatal("expected receipt write error")
-	}
-
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageRequest {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageRequest)
-	}
-	if got := stageStatus(t, run, StageRequest); got == StatusDone {
-		t.Fatalf("request stage status = %q, want not %q", got, StatusDone)
-	}
-}
-
-func TestCompleteCurrentStageRejectsFailedValidatePreviewRepairReceipts(t *testing.T) {
-	initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageValidatePreviewRepair)
-	mustWriteTestFile(t, "demo/slides/01.svg", visibleTextSVG())
-	mustWriteTestFile(t, "demo/receipts/lint.json", `{"status":"failed","issues":[]}`)
-	mustWriteTestFile(t, "demo/receipts/preview.json", `{"status":"failed","slides":[{"path":"slides/01.svg","rendered":false}]}`)
-	mustWriteTestFile(t, "demo/repair_queue.md", "# repair\n")
-	mustWriteTestFile(t, "demo/preview.html", "<!doctype html><title>preview</title>")
-
-	_, err := CompleteCurrentStage("demo")
-	if err == nil {
-		t.Fatal("expected failed lint/preview receipts to block completion")
-	}
-	run := readStatusTestRunFile(t)
-	if run.CurrentStage != StageValidatePreviewRepair {
-		t.Fatalf("run.CurrentStage = %q, want %q", run.CurrentStage, StageValidatePreviewRepair)
-	}
-	if got := stageStatus(t, run, StageValidatePreviewRepair); got == StatusDone {
-		t.Fatalf("validate stage status = %q, want not %q", got, StatusDone)
-	}
-	if _, statErr := os.Stat(filepath.Join("demo", "receipts", "validate_preview_repair.json")); !os.IsNotExist(statErr) {
-		t.Fatalf("final receipt should not be written, stat err = %v", statErr)
-	}
-}
-
-func stageStatus(t *testing.T, run Run, name string) string {
-	t.Helper()
-	for _, stage := range run.Stages {
-		if stage.Name == name {
-			return stage.Status
-		}
-	}
-	t.Fatalf("missing stage %q", name)
-	return ""
-}

internal/svglide/status.go

@@ -1,391 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/fs"
-	"path/filepath"
-	"strings"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-type StatusReport struct {
-	CurrentStage   string   `json:"current_stage"`
-	MissingInputs  []string `json:"missing_inputs"`
-	MissingOutputs []string `json:"missing_outputs"`
-	NextCommand    string   `json:"next_command"`
-}
-
-type NextTaskReport struct {
-	Stage      string   `json:"stage"`
-	PromptPath string   `json:"prompt_path"`
-	Inputs     []string `json:"inputs"`
-	Outputs    []string `json:"outputs"`
-}
-
-func ReadRun(root string) (Run, error) {
-	safeRoot, err := validate.SafeInputPath(root)
-	if err != nil {
-		return Run{}, err
-	}
-	return readRunFile(safeRoot)
-}
-
-func InspectStatus(root string) (StatusReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	stage, err := currentStage(run)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	missingInputs, err := missingRunPaths(safeRoot, stage.Inputs)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	missingOutputs, err := missingRunPaths(safeRoot, stage.Outputs)
-	if err != nil {
-		return StatusReport{}, err
-	}
-	return StatusReport{
-		CurrentStage:   stage.Name,
-		MissingInputs:  missingInputs,
-		MissingOutputs: missingOutputs,
-		NextCommand:    fmt.Sprintf("lark-cli slides +create-svglide --action next --run %s", shellQuote(root)),
-	}, nil
-}
-
-func NextTask(root string) (NextTaskReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	stage, err := currentStage(run)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	missingInputs, err := missingRunPaths(safeRoot, stage.Inputs)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	if len(missingInputs) > 0 {
-		return NextTaskReport{}, fmt.Errorf("current stage %q missing inputs: %s", stage.Name, strings.Join(missingInputs, ", "))
-	}
-	promptPath, err := promptPathForStage(stage.Name)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	inputs, err := validateRunPaths(safeRoot, stage.Inputs)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	outputs, err := validateRunPaths(safeRoot, stage.Outputs)
-	if err != nil {
-		return NextTaskReport{}, err
-	}
-	return NextTaskReport{
-		Stage:      stage.Name,
-		PromptPath: promptPath,
-		Inputs:     inputs,
-		Outputs:    outputs,
-	}, nil
-}
-
-func readRun(root string) (string, Run, error) {
-	safeRoot, err := validate.SafeInputPath(root)
-	if err != nil {
-		return "", Run{}, err
-	}
-	run, err := readRunFile(safeRoot)
-	if err != nil {
-		return "", Run{}, err
-	}
-	return safeRoot, run, nil
-}
-
-func readRunFile(safeRoot string) (Run, error) {
-	raw, err := vfs.ReadFile(filepath.Join(safeRoot, "run.json"))
-	if err != nil {
-		return Run{}, err
-	}
-	var run Run
-	if err := json.Unmarshal(raw, &run); err != nil {
-		return Run{}, fmt.Errorf("read run.json: %w", err)
-	}
-	return run, nil
-}
-
-func currentStage(run Run) (Stage, error) {
-	for _, stage := range run.Stages {
-		if stage.Name == run.CurrentStage {
-			return stage, nil
-		}
-	}
-	return Stage{}, fmt.Errorf("current stage %q not found in run", run.CurrentStage)
-}
-
-func missingRunPaths(safeRoot string, rels []string) ([]string, error) {
-	var missing []string
-	for _, rel := range rels {
-		if hasGlobMeta(rel) {
-			exists, err := runGlobExists(safeRoot, rel)
-			if err != nil {
-				return nil, err
-			}
-			if !exists {
-				missing = append(missing, rel)
-			}
-			continue
-		}
-		exists, err := runRegularFileExists(safeRoot, rel)
-		if err != nil {
-			return nil, fmt.Errorf("lstat run path %q: %w", rel, err)
-		}
-		if !exists {
-			missing = append(missing, rel)
-		}
-	}
-	return missing, nil
-}
-
-func validateRunPaths(safeRoot string, rels []string) ([]string, error) {
-	paths := make([]string, 0, len(rels))
-	for _, rel := range rels {
-		if hasGlobMeta(rel) {
-			if _, _, _, err := validateRunGlobPattern(safeRoot, rel); err != nil {
-				return nil, err
-			}
-		} else {
-			if _, err := safeRunPath(safeRoot, rel); err != nil {
-				return nil, err
-			}
-		}
-		paths = append(paths, rel)
-	}
-	return paths, nil
-}
-
-func runGlobExists(safeRoot, rel string) (bool, error) {
-	dirRel, pattern, dirPath, err := validateRunGlobPattern(safeRoot, rel)
-	if err != nil {
-		return false, err
-	}
-	dirPath, exists, err := runDirectoryExists(safeRoot, dirRel)
-	if err != nil {
-		return false, fmt.Errorf("lstat glob directory for %q: %w", rel, err)
-	}
-	if !exists {
-		return false, nil
-	}
-	entries, err := vfs.ReadDir(dirPath)
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			return false, nil
-		}
-		return false, fmt.Errorf("read glob directory for %q: %w", rel, err)
-	}
-	for _, entry := range entries {
-		matched, err := filepath.Match(pattern, entry.Name())
-		if err != nil {
-			return false, fmt.Errorf("invalid glob pattern %q: %w", rel, err)
-		}
-		if !matched {
-			continue
-		}
-		matchRel := filepath.Join(dirRel, entry.Name())
-		exists, err := runRegularFileExists(safeRoot, matchRel)
-		if err != nil {
-			return false, fmt.Errorf("lstat glob match %q: %w", matchRel, err)
-		}
-		if exists {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-func validateRunGlobPattern(safeRoot, rel string) (string, string, string, error) {
-	if strings.TrimSpace(rel) == "" {
-		return "", "", "", fmt.Errorf("run path must not be empty")
-	}
-	if isAbsoluteRunPath(rel) {
-		return "", "", "", fmt.Errorf("run path %q must be relative to run root", rel)
-	}
-	cleanRel := filepath.Clean(rel)
-	dirRel, pattern := filepath.Split(cleanRel)
-	dirRel = strings.TrimSuffix(dirRel, string(filepath.Separator))
-	if pattern == "" {
-		return "", "", "", fmt.Errorf("glob path %q is missing a file pattern", rel)
-	}
-	if _, err := filepath.Match(pattern, ""); err != nil {
-		return "", "", "", fmt.Errorf("invalid glob pattern %q: %w", rel, err)
-	}
-	if dirRel == "" {
-		dirRel = "."
-	}
-	if hasGlobMeta(dirRel) {
-		return "", "", "", fmt.Errorf("glob path %q is only supported in the file name", rel)
-	}
-	dirPath, err := safeRunPath(safeRoot, dirRel)
-	if err != nil {
-		return "", "", "", err
-	}
-	return dirRel, pattern, dirPath, nil
-}
-
-func runDirectoryExists(safeRoot, rel string) (string, bool, error) {
-	info, path, exists, err := lstatRunPath(safeRoot, rel)
-	if err != nil {
-		return path, false, err
-	}
-	if !exists {
-		return path, false, nil
-	}
-	if !info.IsDir() {
-		return path, false, fmt.Errorf("run path %q is not a directory", rel)
-	}
-	return path, true, nil
-}
-
-func runRegularFileExists(safeRoot, rel string) (bool, error) {
-	info, _, exists, err := lstatRunPath(safeRoot, rel)
-	if err != nil {
-		return false, err
-	}
-	if !exists {
-		return false, nil
-	}
-	return info.Mode().IsRegular(), nil
-}
-
-func lstatRunPath(safeRoot, rel string) (fs.FileInfo, string, bool, error) {
-	path, err := safeRunPath(safeRoot, rel)
-	if err != nil {
-		return nil, "", false, err
-	}
-	cleanRel := filepath.Clean(rel)
-	if cleanRel == "." {
-		info, err := vfs.Lstat(path)
-		if err != nil {
-			if errors.Is(err, fs.ErrNotExist) {
-				return nil, path, false, nil
-			}
-			return nil, path, false, err
-		}
-		if info.Mode()&fs.ModeSymlink != 0 {
-			return nil, path, false, nil
-		}
-		return info, path, true, nil
-	}
-	parts := strings.Split(cleanRel, string(filepath.Separator))
-	cur := safeRoot
-	var info fs.FileInfo
-	for i, part := range parts {
-		if part == "" || part == "." {
-			continue
-		}
-		cur = filepath.Join(cur, part)
-		info, err = vfs.Lstat(cur)
-		if err != nil {
-			if errors.Is(err, fs.ErrNotExist) {
-				return nil, path, false, nil
-			}
-			return nil, path, false, err
-		}
-		if info.Mode()&fs.ModeSymlink != 0 {
-			return nil, path, false, nil
-		}
-		if i < len(parts)-1 && !info.IsDir() {
-			return nil, path, false, fmt.Errorf("run path component %q is not a directory", filepath.Join(parts[:i+1]...))
-		}
-	}
-	if info == nil {
-		return nil, path, false, nil
-	}
-	return info, path, true, nil
-}
-
-func hasGlobMeta(path string) bool {
-	return strings.ContainsAny(path, "*?[")
-}
-
-func safeRunPath(safeRoot, rel string) (string, error) {
-	if strings.TrimSpace(rel) == "" {
-		return "", fmt.Errorf("run path must not be empty")
-	}
-	if isAbsoluteRunPath(rel) {
-		return "", fmt.Errorf("run path %q must be relative to run root", rel)
-	}
-	cleanRel := filepath.Clean(rel)
-	path := filepath.Clean(filepath.Join(safeRoot, cleanRel))
-	rootRel, err := filepath.Rel(safeRoot, path)
-	if err != nil {
-		return "", fmt.Errorf("cannot compare run path %q with run root: %w", rel, err)
-	}
-	if rootRel == ".." || strings.HasPrefix(rootRel, ".."+string(filepath.Separator)) || filepath.IsAbs(rootRel) {
-		return "", fmt.Errorf("run path %q escapes run root", rel)
-	}
-	return path, nil
-}
-
-func isAbsoluteRunPath(path string) bool {
-	path = strings.TrimSpace(path)
-	if filepath.IsAbs(path) || strings.HasPrefix(path, "/") || strings.HasPrefix(path, `\`) {
-		return true
-	}
-	if len(path) >= 3 && path[1] == ':' && (path[2] == '/' || path[2] == '\\') {
-		drive := path[0]
-		return ('A' <= drive && drive <= 'Z') || ('a' <= drive && drive <= 'z')
-	}
-	return false
-}
-
-func shellQuote(value string) string {
-	if value == "" {
-		return "''"
-	}
-	if isShellBareword(value) {
-		return value
-	}
-	return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"
-}
-
-func isShellBareword(value string) bool {
-	for _, r := range value {
-		if ('a' <= r && r <= 'z') || ('A' <= r && r <= 'Z') || ('0' <= r && r <= '9') {
-			continue
-		}
-		if strings.ContainsRune("_@%+=:,./-", r) {
-			continue
-		}
-		return false
-	}
-	return true
-}
-
-func promptPathForStage(stage string) (string, error) {
-	switch stage {
-	case StageRequest:
-		return "prompts/01_request.task.md", nil
-	case StageResearch:
-		return "prompts/02_research.task.md", nil
-	case StageDesignBrief:
-		return "prompts/03_design_brief.task.md", nil
-	case StageOutline:
-		return "prompts/04_outline.task.md", nil
-	case StageSlideContent:
-		return "prompts/05_slide_content.task.md", nil
-	case StageAssets:
-		return "prompts/06_assets.task.md", nil
-	case StageSVGAuthor:
-		return "prompts/07_svg_author.task.md", nil
-	case StageValidatePreviewRepair:
-		return "prompts/08_repair.task.md", nil
-	default:
-		return "", fmt.Errorf("stage %q has no prompt mapping", stage)
-	}
-}

internal/svglide/status_test.go

@@ -1,449 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-)
-
-func TestStatusReportsMissingOutputs(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.Remove(filepath.Join("demo", "request", "source_manifest.json")); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if status.CurrentStage != StageRequest {
-		t.Fatalf("CurrentStage = %q, want %q", status.CurrentStage, StageRequest)
-	}
-	if !slices.Contains(status.MissingOutputs, "request/source_manifest.json") {
-		t.Fatalf("MissingOutputs = %v, want request/source_manifest.json", status.MissingOutputs)
-	}
-	if len(status.MissingInputs) != 0 {
-		t.Fatalf("MissingInputs = %v, want empty", status.MissingInputs)
-	}
-	if status.NextCommand != "lark-cli slides +create-svglide --action next --run demo" {
-		t.Fatalf("NextCommand = %q, want --action next shortcut with caller root", status.NextCommand)
-	}
-}
-
-func TestStatusQuotesNextCommandRunPath(t *testing.T) {
-	tests := []struct {
-		root string
-		want string
-	}{
-		{
-			root: "demo dir",
-			want: "lark-cli slides +create-svglide --action next --run 'demo dir'",
-		},
-		{
-			root: "demo' dir",
-			want: "lark-cli slides +create-svglide --action next --run 'demo'\\'' dir'",
-		},
-		{
-			root: "demo trail ",
-			want: "lark-cli slides +create-svglide --action next --run 'demo trail '",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.root, func(t *testing.T) {
-			cwd := initStatusTestRunAt(t, tt.root)
-
-			status, err := InspectStatus(tt.root)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			if status.NextCommand != tt.want {
-				t.Fatalf("NextCommand = %q, want %q", status.NextCommand, tt.want)
-			}
-			if strings.Contains(status.NextCommand, cwd) {
-				t.Fatalf("NextCommand = %q, should not contain absolute safe root %q", status.NextCommand, cwd)
-			}
-		})
-	}
-}
-
-func TestNextReturnsCurrentTaskPrompt(t *testing.T) {
-	initStatusTestRun(t)
-
-	next, err := NextTask("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if next.Stage != StageRequest {
-		t.Fatalf("Stage = %q, want %q", next.Stage, StageRequest)
-	}
-	if next.PromptPath != "prompts/01_request.task.md" {
-		t.Fatalf("PromptPath = %q, want prompts/01_request.task.md", next.PromptPath)
-	}
-	if filepath.IsAbs(next.PromptPath) {
-		t.Fatalf("PromptPath = %q, want relative path", next.PromptPath)
-	}
-	if _, err := os.Stat(filepath.Join("demo", next.PromptPath)); err != nil {
-		t.Fatalf("missing prompt %s: %v", next.PromptPath, err)
-	}
-	if len(next.Inputs) != 0 {
-		t.Fatalf("Inputs = %v, want empty", next.Inputs)
-	}
-	if !slices.Equal(next.Outputs, []string{"request/request.json", "request/source_manifest.json"}) {
-		t.Fatalf("Outputs = %v, want request outputs", next.Outputs)
-	}
-}
-
-func TestInspectStatusRejectsUnsafeRunPath(t *testing.T) {
-	t.Chdir(t.TempDir())
-
-	if _, err := InspectStatus("../escape"); err == nil {
-		t.Fatal("expected unsafe run path refusal")
-	}
-}
-
-func TestReadRunReadsRunJSONAndRejectsAbsoluteRunPath(t *testing.T) {
-	cwd := initStatusTestRun(t)
-
-	run, err := ReadRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if run.Title != "Demo" || run.CurrentStage != StageRequest {
-		t.Fatalf("unexpected run: %+v", run)
-	}
-
-	if _, err := ReadRun(filepath.Join(cwd, "demo")); err == nil {
-		t.Fatal("expected absolute run path refusal")
-	}
-}
-
-func TestInspectStatusRejectsEscapingStagePath(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageRequest, []string{"../outside.json"})
-	writeStatusTestRunFile(t, run)
-
-	if _, err := InspectStatus("demo"); err == nil {
-		t.Fatal("expected escaping stage output path refusal")
-	}
-}
-
-func TestInspectStatusReturnsStatErrorsThatAreNotMissing(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.RemoveAll(filepath.Join("demo", "request")); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join("demo", "request"), []byte("not a directory"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := InspectStatus("demo"); err == nil {
-		t.Fatal("expected stat error when output parent is a file")
-	}
-}
-
-func TestInspectStatusReportsDirectoryArtifactAsMissing(t *testing.T) {
-	initStatusTestRun(t)
-	path := filepath.Join("demo", "request", "source_manifest.json")
-	if err := os.Remove(path); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Mkdir(path, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "request/source_manifest.json") {
-		t.Fatalf("MissingOutputs = %v, want directory artifact to be missing", status.MissingOutputs)
-	}
-}
-
-func TestNextTaskRejectsEscapingStagePath(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageRequest, []string{"../outside.json"})
-	writeStatusTestRunFile(t, run)
-
-	if _, err := NextTask("demo"); err == nil {
-		t.Fatal("expected escaping stage output path refusal")
-	}
-}
-
-func TestNextTaskRejectsMissingCurrentStageInputs(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageDesignBrief
-	writeStatusTestRunFile(t, run)
-
-	if _, err := NextTask("demo"); err == nil {
-		t.Fatal("expected missing current stage inputs to reject next task")
-	}
-}
-
-func TestNextTaskRejectsResearchMissingSourceManifest(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.Remove(filepath.Join("demo", "request", "source_manifest.json")); err != nil {
-		t.Fatal(err)
-	}
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageResearch
-	writeStatusTestRunFile(t, run)
-
-	if _, err := NextTask("demo"); err == nil {
-		t.Fatal("expected missing research source manifest to reject next task")
-	}
-}
-
-func TestNextTaskRejectsOutlineMissingVisualSystem(t *testing.T) {
-	initStatusTestRun(t)
-	if err := os.WriteFile(filepath.Join("demo", "brief", "design_brief.json"), []byte("{}"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageOutline
-	writeStatusTestRunFile(t, run)
-
-	if _, err := NextTask("demo"); err == nil {
-		t.Fatal("expected missing outline visual system to reject next task")
-	}
-}
-
-func TestInspectStatusReportsMissingGlobUntilMatched(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = StageSVGAuthor
-	setStatusTestStageOutputs(t, &run, StageSVGAuthor, []string{"slides/*.svg"})
-	writeStatusTestRunFile(t, run)
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "slides/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want slides/*.svg", status.MissingOutputs)
-	}
-
-	if err := os.WriteFile(filepath.Join("demo", "slides", "01.svg"), []byte("<svg/>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	status, err = InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if slices.Contains(status.MissingOutputs, "slides/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want glob satisfied by slides/01.svg", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusDoesNotSatisfyGlobThroughIntermediateSymlink(t *testing.T) {
-	cwd := initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageSVGAuthor)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageSVGAuthor, []string{"link/bar/*.svg"})
-	writeStatusTestRunFile(t, run)
-	outside := filepath.Join(filepath.Dir(cwd), "outside")
-	if err := os.MkdirAll(filepath.Join(outside, "bar"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(outside, "bar", "01.svg"), []byte("<svg/>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "link")); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "link/bar/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want intermediate symlink glob to leave link/bar/*.svg missing", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusDoesNotSatisfyArtifactThroughIntermediateSymlink(t *testing.T) {
-	cwd := initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageRequest, []string{"link/request.json"})
-	writeStatusTestRunFile(t, run)
-	outside := filepath.Join(filepath.Dir(cwd), "outside")
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(outside, "request.json"), []byte("{}"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "link")); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "link/request.json") {
-		t.Fatalf("MissingOutputs = %v, want intermediate symlink artifact to leave link/request.json missing", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusDoesNotSatisfyGlobWithEscapingSymlinkDirectory(t *testing.T) {
-	cwd := initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageSVGAuthor)
-	if err := os.RemoveAll(filepath.Join("demo", "slides")); err != nil {
-		t.Fatal(err)
-	}
-	outsideSlides := filepath.Join(filepath.Dir(cwd), "outside-slides")
-	if err := os.MkdirAll(outsideSlides, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(outsideSlides, "01.svg"), []byte("<svg/>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outsideSlides, filepath.Join("demo", "slides")); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "slides/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want symlink directory glob to leave slides/*.svg missing", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusDoesNotSatisfyGlobWithDirectory(t *testing.T) {
-	initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageSVGAuthor)
-	if err := os.Mkdir(filepath.Join("demo", "slides", "01.svg"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "slides/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want directory match to leave slides/*.svg missing", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusDoesNotSatisfyGlobWithEscapingSymlink(t *testing.T) {
-	cwd := initStatusTestRun(t)
-	setCurrentStageForStatusTest(t, StageSVGAuthor)
-	outside := filepath.Join(filepath.Dir(cwd), "outside.svg")
-	if err := os.WriteFile(outside, []byte("<svg/>"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "slides", "01.svg")); err != nil {
-		t.Fatal(err)
-	}
-
-	status, err := InspectStatus("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Contains(status.MissingOutputs, "slides/*.svg") {
-		t.Fatalf("MissingOutputs = %v, want symlink match to leave slides/*.svg missing", status.MissingOutputs)
-	}
-}
-
-func TestInspectStatusRejectsInvalidGlobPattern(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageRequest, []string{"slides/[.svg"})
-	writeStatusTestRunFile(t, run)
-
-	if _, err := InspectStatus("demo"); err == nil {
-		t.Fatal("expected invalid glob pattern error")
-	}
-}
-
-func TestNextTaskRejectsInvalidGlobPattern(t *testing.T) {
-	initStatusTestRun(t)
-	run := readStatusTestRunFile(t)
-	setStatusTestStageOutputs(t, &run, StageRequest, []string{"slides/[.svg"})
-	writeStatusTestRunFile(t, run)
-
-	if _, err := NextTask("demo"); err == nil {
-		t.Fatal("expected invalid glob pattern error")
-	}
-}
-
-func initStatusTestRun(t *testing.T) string {
-	return initStatusTestRunAt(t, "demo")
-}
-
-func initStatusTestRunAt(t *testing.T, root string) string {
-	t.Helper()
-	cwd := t.TempDir()
-	t.Chdir(cwd)
-	if err := os.WriteFile("source.md", []byte("# Demo"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	initRoot := root
-	if trimmed := strings.TrimSpace(root); trimmed != root {
-		initRoot = trimmed
-	}
-	if err := InitRun(initRoot, InitOptions{Title: "Demo", Input: "source.md"}); err != nil {
-		t.Fatal(err)
-	}
-	if initRoot != root {
-		if err := os.Rename(initRoot, root); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return cwd
-}
-
-func readStatusTestRunFile(t *testing.T) Run {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("demo", "run.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var run Run
-	if err := json.Unmarshal(raw, &run); err != nil {
-		t.Fatal(err)
-	}
-	return run
-}
-
-func writeStatusTestRunFile(t *testing.T, run Run) {
-	t.Helper()
-	raw, err := json.MarshalIndent(run, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw = append(raw, '\n')
-	if err := os.WriteFile(filepath.Join("demo", "run.json"), raw, 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func setStatusTestStageOutputs(t *testing.T, run *Run, stageName string, outputs []string) {
-	t.Helper()
-	for i := range run.Stages {
-		if run.Stages[i].Name == stageName {
-			run.Stages[i].Outputs = outputs
-			return
-		}
-	}
-	t.Fatalf("missing stage %q", stageName)
-}
-
-func setCurrentStageForStatusTest(t *testing.T, stageName string) {
-	t.Helper()
-	run := readStatusTestRunFile(t)
-	run.CurrentStage = stageName
-	writeStatusTestRunFile(t, run)
-}

internal/svglide/validate.go

@@ -1,440 +0,0 @@
-package svglide
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-const slideNamespace = "https://slides.bytedance.com/ns"
-const svgNamespace = "http://www.w3.org/2000/svg"
-const xlinkNamespace = "http://www.w3.org/1999/xlink"
-
-type ValidationReport struct {
-	OK     bool              `json:"ok"`
-	Issues []ValidationIssue `json:"issues"`
-}
-
-type ValidationIssue struct {
-	Path     string `json:"path"`
-	Code     string `json:"code,omitempty"`
-	Message  string `json:"message"`
-	Severity string `json:"severity,omitempty"`
-}
-
-type validationDeck struct {
-	Slides []validationDeckSlide `json:"slides"`
-}
-
-type validationDeckSlide struct {
-	Path string `json:"path"`
-}
-
-type svgViewBox struct {
-	Width  float64
-	Height float64
-	Valid  bool
-}
-
-type svgLintElement struct {
-	Excluded      bool
-	TextCandidate bool
-}
-
-func ValidateRun(root string) (ValidationReport, error) {
-	safeRoot, run, err := readRun(root)
-	if err != nil {
-		return ValidationReport{}, err
-	}
-
-	deckPath := strings.TrimSpace(run.Artifacts.Deck)
-	if deckPath == "" {
-		return failValidation(safeRoot, ValidationIssue{Code: "svglide.deck", Message: "deck artifact path is empty"}, fmt.Errorf("deck artifact path is empty"))
-	}
-	deckRaw, err := readRunRegularArtifact(safeRoot, deckPath)
-	if err != nil {
-		issue := ValidationIssue{Path: deckPath, Code: "svglide.deck", Message: fmt.Sprintf("deck %q: %v", deckPath, err)}
-		return failValidation(safeRoot, issue, fmt.Errorf("read deck %q: %w", deckPath, err))
-	}
-	var deck validationDeck
-	if err := json.Unmarshal(deckRaw, &deck); err != nil {
-		issue := ValidationIssue{Path: deckPath, Code: "svglide.deck", Message: fmt.Sprintf("deck %q contains invalid JSON: %v", deckPath, err)}
-		return failValidation(safeRoot, issue, fmt.Errorf("read deck %q: %w", deckPath, err))
-	}
-	if len(deck.Slides) == 0 {
-		issue := ValidationIssue{Path: deckPath, Code: "svglide.deck", Message: fmt.Sprintf("deck %q contains no slides", deckPath)}
-		return failValidation(safeRoot, issue, fmt.Errorf("deck %q contains no slides", deckPath))
-	}
-
-	report := ValidationReport{Issues: []ValidationIssue{}}
-	for _, slide := range deck.Slides {
-		slidePath := strings.TrimSpace(slide.Path)
-		if slidePath == "" {
-			report.Issues = append(report.Issues, ValidationIssue{Code: "svglide.path", Message: "slide path must not be empty"})
-			continue
-		}
-
-		raw, err := readRunRegularArtifact(safeRoot, slidePath)
-		if err != nil {
-			report.Issues = append(report.Issues, ValidationIssue{Path: slidePath, Code: "svglide.path", Message: err.Error()})
-			continue
-		}
-		report.Issues = append(report.Issues, lintSVG(slidePath, raw)...)
-	}
-	report = normalizeValidationReport(report)
-
-	if err := writeValidationArtifacts(safeRoot, report); err != nil {
-		return report, err
-	}
-	return report, nil
-}
-
-func failValidation(safeRoot string, issue ValidationIssue, err error) (ValidationReport, error) {
-	report := ValidationReport{Issues: []ValidationIssue{issue}}
-	report = normalizeValidationReport(report)
-	if writeErr := writeValidationArtifacts(safeRoot, report); writeErr != nil {
-		if err != nil {
-			return report, fmt.Errorf("%w; write validation artifacts: %v", err, writeErr)
-		}
-		return report, writeErr
-	}
-	return report, nil
-}
-
-func readRunRegularArtifact(safeRoot string, rel string) ([]byte, error) {
-	info, path, exists, err := lstatRunPath(safeRoot, rel)
-	if err != nil {
-		return nil, err
-	}
-	if !exists || !info.Mode().IsRegular() {
-		return nil, fmt.Errorf("run path %q is missing or not a regular file inside run root", rel)
-	}
-	raw, err := vfs.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("read run path %q: %w", rel, err)
-	}
-	return raw, nil
-}
-
-func lintSVG(path string, raw []byte) []ValidationIssue {
-	decoder := xml.NewDecoder(bytes.NewReader(raw))
-	var issues []ValidationIssue
-	var rootSeen bool
-	var rootIsSVG bool
-	var hasSlideRole bool
-	var hasViewBox bool
-	var hasVisibleContent bool
-	var viewBox svgViewBox
-	var stack []svgLintElement
-
-	for {
-		token, err := decoder.Token()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return []ValidationIssue{{Path: path, Code: "svglide.xml", Message: fmt.Sprintf("invalid XML: %v", err)}}
-		}
-		switch typed := token.(type) {
-		case xml.StartElement:
-			parentExcluded := len(stack) > 0 && stack[len(stack)-1].Excluded
-			excluded := parentExcluded || elementIsHidden(typed) || elementIsNonRendering(typed)
-			ctx := svgLintElement{
-				Excluded:      excluded,
-				TextCandidate: elementIsTextCandidate(typed),
-			}
-			if !rootSeen {
-				rootSeen = true
-				rootIsSVG = typed.Name.Local == "svg" && typed.Name.Space == svgNamespace
-				hasSlideRole = hasRootSlideRole(typed)
-				viewBox, hasViewBox = rootViewBox(typed)
-				stack = append(stack, ctx)
-				continue
-			}
-			if elementCountsAsVisibleContent(typed, viewBox, excluded) {
-				hasVisibleContent = true
-			}
-			stack = append(stack, ctx)
-		case xml.CharData:
-			if strings.TrimSpace(string(typed)) != "" && activeVisibleTextCandidate(stack) {
-				hasVisibleContent = true
-			}
-		case xml.EndElement:
-			if len(stack) > 0 {
-				stack = stack[:len(stack)-1]
-			}
-		default:
-			continue
-		}
-	}
-
-	if !rootSeen {
-		return []ValidationIssue{{Path: path, Code: "svglide.xml", Message: "invalid XML: missing root element"}}
-	}
-	if !rootIsSVG {
-		issues = append(issues, ValidationIssue{Path: path, Code: "svglide.root", Message: "root element must be <svg>"})
-	}
-	if !hasSlideRole {
-		issues = append(issues, ValidationIssue{Path: path, Code: "svglide.slide_role", Message: `root element must include slide:role="slide"`})
-	}
-	if !hasViewBox {
-		issues = append(issues, ValidationIssue{Path: path, Code: "svglide.viewbox", Message: "root element must include viewBox"})
-	} else if !viewBox.Valid {
-		issues = append(issues, ValidationIssue{Path: path, Code: "svglide.viewbox", Message: "root element must include valid viewBox"})
-	}
-	if rootIsSVG && !hasVisibleContent {
-		issues = append(issues, ValidationIssue{Path: path, Code: "svglide.visible_content", Message: "slide contains only background/placeholder content"})
-	}
-	return issues
-}
-
-func hasRootSlideRole(start xml.StartElement) bool {
-	for _, attr := range start.Attr {
-		if strings.TrimSpace(attr.Value) != "slide" {
-			continue
-		}
-		if attr.Name.Local == "role" && attr.Name.Space == slideNamespace {
-			return true
-		}
-	}
-	return false
-}
-
-func rootViewBox(start xml.StartElement) (svgViewBox, bool) {
-	for _, attr := range start.Attr {
-		if attr.Name.Space != "" || attr.Name.Local != "viewBox" || strings.TrimSpace(attr.Value) == "" {
-			continue
-		}
-		return parseViewBox(attr.Value), true
-	}
-	return svgViewBox{}, false
-}
-
-func parseViewBox(value string) svgViewBox {
-	fields := strings.Fields(strings.ReplaceAll(value, ",", " "))
-	if len(fields) != 4 {
-		return svgViewBox{}
-	}
-	values := make([]float64, 4)
-	for i, field := range fields {
-		parsed, err := strconv.ParseFloat(field, 64)
-		if err != nil || math.IsNaN(parsed) || math.IsInf(parsed, 0) {
-			return svgViewBox{}
-		}
-		values[i] = parsed
-	}
-	width := values[2]
-	height := values[3]
-	if width <= 0 || height <= 0 {
-		return svgViewBox{}
-	}
-	return svgViewBox{Width: width, Height: height, Valid: true}
-}
-
-func elementCountsAsVisibleContent(start xml.StartElement, viewBox svgViewBox, excluded bool) bool {
-	if excluded {
-		return false
-	}
-	if start.Name.Space != svgNamespace {
-		return false
-	}
-	if hasSemanticMarker(start, "background", "placeholder") {
-		return false
-	}
-	switch start.Name.Local {
-	case "text", "tspan":
-		return false
-	case "foreignObject", "chart":
-		return true
-	case "image", "use":
-		return elementHasHref(start)
-	case "g":
-		return hasSemanticMarker(start, "chart", "shape")
-	case "path", "circle", "ellipse", "line", "polyline", "polygon":
-		return true
-	case "rect":
-		return !isBackgroundRect(start, viewBox)
-	default:
-		return hasSemanticMarker(start, "chart", "shape")
-	}
-}
-
-func activeVisibleTextCandidate(stack []svgLintElement) bool {
-	for i := len(stack) - 1; i >= 0; i-- {
-		if stack[i].Excluded {
-			return false
-		}
-		if stack[i].TextCandidate {
-			return true
-		}
-	}
-	return false
-}
-
-func elementIsTextCandidate(start xml.StartElement) bool {
-	return start.Name.Space == svgNamespace && (start.Name.Local == "text" || start.Name.Local == "tspan")
-}
-
-func elementIsHidden(start xml.StartElement) bool {
-	for _, attr := range start.Attr {
-		if attr.Name.Space != "" {
-			continue
-		}
-		switch attr.Name.Local {
-		case "display":
-			if strings.EqualFold(strings.TrimSpace(attr.Value), "none") {
-				return true
-			}
-		case "visibility":
-			if strings.EqualFold(strings.TrimSpace(attr.Value), "hidden") {
-				return true
-			}
-		case "opacity":
-			if opacityIsZero(attr.Value) {
-				return true
-			}
-		case "style":
-			if styleHidesElement(attr.Value) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func styleHidesElement(style string) bool {
-	for _, declaration := range strings.Split(style, ";") {
-		name, value, ok := strings.Cut(declaration, ":")
-		if !ok {
-			continue
-		}
-		switch strings.ToLower(strings.TrimSpace(name)) {
-		case "display":
-			if strings.EqualFold(strings.TrimSpace(value), "none") {
-				return true
-			}
-		case "visibility":
-			if strings.EqualFold(strings.TrimSpace(value), "hidden") {
-				return true
-			}
-		case "opacity":
-			if opacityIsZero(value) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func opacityIsZero(value string) bool {
-	parsed, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
-	if err != nil || math.IsNaN(parsed) || math.IsInf(parsed, 0) {
-		return false
-	}
-	return floatEqual(parsed, 0)
-}
-
-func elementIsNonRendering(start xml.StartElement) bool {
-	if start.Name.Space != svgNamespace {
-		return false
-	}
-	switch start.Name.Local {
-	case "defs", "symbol", "clipPath", "mask", "pattern", "linearGradient", "radialGradient", "marker", "metadata", "title", "desc", "style", "script":
-		return true
-	default:
-		return false
-	}
-}
-
-func elementHasHref(start xml.StartElement) bool {
-	for _, attr := range start.Attr {
-		if attr.Name.Local != "href" || strings.TrimSpace(attr.Value) == "" {
-			continue
-		}
-		if attr.Name.Space == "" || attr.Name.Space == xlinkNamespace {
-			return true
-		}
-	}
-	return false
-}
-
-func hasSemanticMarker(start xml.StartElement, terms ...string) bool {
-	for _, attr := range start.Attr {
-		if attr.Name.Space != "" {
-			continue
-		}
-		name := strings.ToLower(attr.Name.Local)
-		if name != "role" && name != "class" && name != "id" && !strings.HasPrefix(name, "data-") {
-			continue
-		}
-		value := strings.ToLower(attr.Value)
-		for _, term := range terms {
-			if strings.Contains(value, term) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func isBackgroundRect(start xml.StartElement, viewBox svgViewBox) bool {
-	if hasSemanticMarker(start, "background", "placeholder") {
-		return true
-	}
-	width := attrValue(start, "width")
-	height := attrValue(start, "height")
-	if width == "100%" && height == "100%" {
-		return true
-	}
-	if !viewBox.Valid {
-		return false
-	}
-	x := attrFloatDefault(start, "x", 0)
-	y := attrFloatDefault(start, "y", 0)
-	w, okW := parseAttrFloat(width)
-	h, okH := parseAttrFloat(height)
-	if !okW || !okH {
-		return false
-	}
-	return floatEqual(x, 0) && floatEqual(y, 0) && floatEqual(w, viewBox.Width) && floatEqual(h, viewBox.Height)
-}
-
-func attrValue(start xml.StartElement, name string) string {
-	for _, attr := range start.Attr {
-		if attr.Name.Space == "" && attr.Name.Local == name {
-			return strings.TrimSpace(attr.Value)
-		}
-	}
-	return ""
-}
-
-func attrFloatDefault(start xml.StartElement, name string, fallback float64) float64 {
-	value := attrValue(start, name)
-	if value == "" {
-		return fallback
-	}
-	parsed, ok := parseAttrFloat(value)
-	if !ok {
-		return fallback
-	}
-	return parsed
-}
-
-func parseAttrFloat(value string) (float64, bool) {
-	parsed, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
-	if err != nil {
-		return 0, false
-	}
-	return parsed, true
-}
-
-func floatEqual(a float64, b float64) bool {
-	return math.Abs(a-b) < 0.001
-}

internal/svglide/validate_test.go

@@ -1,711 +0,0 @@
-package svglide
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestValidateRunRejectsBackgroundOnlySVGAndWritesRepairArtifacts(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), backgroundOnlySVG())
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if report.OK {
-		t.Fatalf("OK = true, want false")
-	}
-	if len(report.Issues) == 0 {
-		t.Fatal("expected background-only SVG issue")
-	}
-	if !validationIssuesContain(report.Issues, "background") {
-		t.Fatalf("Issues = %+v, want background/placeholder issue", report.Issues)
-	}
-
-	raw, err := os.ReadFile(filepath.Join("demo", "receipts", "lint.json"))
-	if err != nil {
-		t.Fatalf("missing lint receipt: %v", err)
-	}
-	var receipt ValidationReport
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatalf("lint receipt is not ValidationReport JSON: %v", err)
-	}
-	if receipt.OK || len(receipt.Issues) == 0 {
-		t.Fatalf("lint receipt = %+v, want failing issues", receipt)
-	}
-	var lintReceipt validationLintReceipt
-	if err := json.Unmarshal(raw, &lintReceipt); err != nil {
-		t.Fatalf("lint receipt is not schema-compatible JSON: %v", err)
-	}
-	if lintReceipt.Status != "failed" {
-		t.Fatalf("lint receipt status = %q, want failed", lintReceipt.Status)
-	}
-	if lintReceipt.Issues[0].Code == "" || lintReceipt.Issues[0].Severity == "" {
-		t.Fatalf("lint receipt issue = %+v, want code and severity", lintReceipt.Issues[0])
-	}
-
-	queue, err := os.ReadFile(filepath.Join("demo", "repair_queue.md"))
-	if err != nil {
-		t.Fatalf("missing repair queue: %v", err)
-	}
-	if !strings.Contains(string(queue), "slides/01.svg") {
-		t.Fatalf("repair queue = %q, want slide path", string(queue))
-	}
-}
-
-func TestValidateRunPassesVisibleTextSVG(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !report.OK {
-		t.Fatalf("OK = false, issues = %+v", report.Issues)
-	}
-	if len(report.Issues) != 0 {
-		t.Fatalf("Issues = %+v, want empty", report.Issues)
-	}
-	queue, err := os.ReadFile(filepath.Join("demo", "repair_queue.md"))
-	if err != nil {
-		t.Fatalf("missing repair queue: %v", err)
-	}
-	if strings.TrimSpace(string(queue)) != "No repair needed." {
-		t.Fatalf("repair queue = %q, want no repair text", string(queue))
-	}
-}
-
-func TestValidateRunRejectsEscapingSlidePath(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "../outside.svg")
-	writeValidateTestFile(t, "outside.svg", visibleTextSVG())
-
-	report, err := ValidateRun("demo")
-	if err == nil && report.OK {
-		t.Fatalf("ValidateRun OK with escaping slide path: %+v", report)
-	}
-}
-
-func TestValidateRunRejectsSlideSymlinks(t *testing.T) {
-	tests := []struct {
-		name      string
-		deckPath  string
-		setupLink func(t *testing.T, outside string)
-	}{
-		{
-			name:     "file symlink",
-			deckPath: "slides/01.svg",
-			setupLink: func(t *testing.T, outside string) {
-				if err := os.Symlink(filepath.Join(outside, "01.svg"), filepath.Join("demo", "slides", "01.svg")); err != nil {
-					t.Fatal(err)
-				}
-			},
-		},
-		{
-			name:     "intermediate symlink",
-			deckPath: "slides/link/01.svg",
-			setupLink: func(t *testing.T, outside string) {
-				if err := os.Symlink(outside, filepath.Join("demo", "slides", "link")); err != nil {
-					t.Fatal(err)
-				}
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cwd := initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", tt.deckPath)
-			outside := filepath.Join(filepath.Dir(cwd), "outside")
-			if err := os.MkdirAll(outside, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			if err := os.WriteFile(filepath.Join(outside, "01.svg"), []byte(visibleTextSVG()), 0o644); err != nil {
-				t.Fatal(err)
-			}
-			tt.setupLink(t, outside)
-
-			report, err := ValidateRun("demo")
-			if err == nil && report.OK {
-				t.Fatalf("ValidateRun OK with symlinked slide path: %+v", report)
-			}
-		})
-	}
-}
-
-func TestValidateRunRejectsDeckSymlinks(t *testing.T) {
-	tests := []struct {
-		name      string
-		deckPath  string
-		setupLink func(t *testing.T, outside string)
-	}{
-		{
-			name:     "file symlink",
-			deckPath: filepath.Join("demo", "outline", "deck.json"),
-			setupLink: func(t *testing.T, outside string) {
-				if err := os.Remove(filepath.Join("demo", "outline", "deck.json")); err != nil {
-					t.Fatal(err)
-				}
-				if err := os.Symlink(filepath.Join(outside, "deck.json"), filepath.Join("demo", "outline", "deck.json")); err != nil {
-					t.Fatal(err)
-				}
-			},
-		},
-		{
-			name:     "intermediate symlink",
-			deckPath: filepath.Join("demo", "outline_link", "deck.json"),
-			setupLink: func(t *testing.T, outside string) {
-				run := readValidateTestRunFile(t)
-				run.Artifacts.Deck = "outline_link/deck.json"
-				writeValidateTestRunFile(t, run)
-				if err := os.Symlink(outside, filepath.Join("demo", "outline_link")); err != nil {
-					t.Fatal(err)
-				}
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cwd := initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-			outside := filepath.Join(filepath.Dir(cwd), "outside")
-			if err := os.MkdirAll(outside, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			writeMinimalDeckAt(t, filepath.Join(outside, "deck.json"), "slides/01.svg")
-			tt.setupLink(t, outside)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.OK {
-				t.Fatalf("ValidateRun OK with symlinked deck path %q: %+v", tt.deckPath, report)
-			}
-		})
-	}
-}
-
-func TestValidateRunRejectsEmptyDeck(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo")
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertValidationFailureArtifacts(t, "demo", report, "no slides")
-}
-
-func TestValidateRunWritesRepairArtifactsForDeckReadFailures(t *testing.T) {
-	tests := []struct {
-		name    string
-		setup   func(t *testing.T)
-		wantErr string
-	}{
-		{
-			name: "missing deck",
-			setup: func(t *testing.T) {
-				if err := os.Remove(filepath.Join("demo", "outline", "deck.json")); err != nil {
-					t.Fatal(err)
-				}
-			},
-			wantErr: "deck",
-		},
-		{
-			name: "invalid deck json",
-			setup: func(t *testing.T) {
-				writeValidateTestFile(t, filepath.Join("demo", "outline", "deck.json"), `{`)
-			},
-			wantErr: "deck",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			tt.setup(t)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			assertValidationFailureArtifacts(t, "demo", report, tt.wantErr)
-		})
-	}
-}
-
-func TestValidateRunReadsDeckFromRunArtifacts(t *testing.T) {
-	initValidateTestRun(t)
-	run := readValidateTestRunFile(t)
-	run.Artifacts.Deck = "custom/deck.json"
-	writeValidateTestRunFile(t, run)
-	writeMinimalDeck(t, "demo", "slides/bad.svg")
-	writeMinimalDeckAt(t, filepath.Join("demo", "custom", "deck.json"), "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !report.OK {
-		t.Fatalf("OK = false, issues = %+v", report.Issues)
-	}
-}
-
-func TestValidateRunReportsInvalidXML(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), `<svg><text>broken`)
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if report.OK {
-		t.Fatalf("OK = true, want false")
-	}
-	if !validationIssuesContain(report.Issues, "XML") && !validationIssuesContain(report.Issues, "xml") {
-		t.Fatalf("Issues = %+v, want XML parse issue", report.Issues)
-	}
-}
-
-func TestValidateRunRequiresSVGRootSlideRoleAndViewBox(t *testing.T) {
-	tests := []struct {
-		name string
-		svg  string
-		want string
-	}{
-		{
-			name: "non svg root",
-			svg:  `<html><body>not svg</body></html>`,
-			want: "<svg>",
-		},
-		{
-			name: "wrong svg namespace",
-			svg:  `<svg xmlns="https://wrong.example/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><text>hello</text></svg>`,
-			want: "<svg>",
-		},
-		{
-			name: "missing slide role",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 960 540"><text>hello</text></svg>`,
-			want: `slide:role`,
-		},
-		{
-			name: "missing viewBox",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide"><text>hello</text></svg>`,
-			want: `viewBox`,
-		},
-		{
-			name: "wrong namespaced slide role",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:foo="https://wrong.example" foo:role="slide" viewBox="0 0 960 540"><text>hello</text></svg>`,
-			want: `slide:role`,
-		},
-		{
-			name: "unbound slide prefix role",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" slide:role="slide" viewBox="0 0 960 540"><text>hello</text></svg>`,
-			want: `slide:role`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), tt.svg)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.OK {
-				t.Fatalf("OK = true, want false")
-			}
-			if !validationIssuesContain(report.Issues, tt.want) {
-				t.Fatalf("Issues = %+v, want %q", report.Issues, tt.want)
-			}
-		})
-	}
-}
-
-func TestValidateRunRejectsInvalidViewBox(t *testing.T) {
-	tests := []struct {
-		name string
-		svg  string
-	}{
-		{
-			name: "bad viewBox with text",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="bad"><text>hello</text></svg>`,
-		},
-		{
-			name: "bad viewBox origin fields",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="bad bad 960 540"><text>hello</text></svg>`,
-		},
-		{
-			name: "nan viewBox width",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 NaN 540"><text>hello</text></svg>`,
-		},
-		{
-			name: "zero viewBox with text",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 0 540"><text>hello</text></svg>`,
-		},
-		{
-			name: "bad viewBox with full page rect",
-			svg:  `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="bad"><rect width="960" height="540" fill="#fff"/></svg>`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), tt.svg)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.OK {
-				t.Fatalf("OK = true, want false")
-			}
-			if !validationIssuesContain(report.Issues, "viewBox") {
-				t.Fatalf("Issues = %+v, want viewBox issue", report.Issues)
-			}
-		})
-	}
-}
-
-func TestValidateRunIgnoresNonVisibleContent(t *testing.T) {
-	tests := []struct {
-		name string
-		body string
-	}{
-		{
-			name: "text in defs",
-			body: `<defs><text>hidden template</text></defs>`,
-		},
-		{
-			name: "display none text",
-			body: `<text display="none">hidden</text>`,
-		},
-		{
-			name: "visibility hidden text",
-			body: `<text visibility="hidden">hidden</text>`,
-		},
-		{
-			name: "style display none text",
-			body: `<text style="display:none">hidden</text>`,
-		},
-		{
-			name: "style visibility hidden text",
-			body: `<text style="visibility:hidden">hidden</text>`,
-		},
-		{
-			name: "opacity zero text",
-			body: `<text opacity="0">hidden</text>`,
-		},
-		{
-			name: "style opacity zero text",
-			body: `<text style="opacity:0">hidden</text>`,
-		},
-		{
-			name: "empty text",
-			body: `<text>   </text>`,
-		},
-		{
-			name: "image without href",
-			body: `<image width="120" height="80"/>`,
-		},
-		{
-			name: "use without href",
-			body: `<use x="10" y="10"/>`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			svg := `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540">` + tt.body + `</svg>`
-			writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), svg)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.OK {
-				t.Fatalf("OK = true, want false")
-			}
-			if !validationIssuesContain(report.Issues, "background") && !validationIssuesContain(report.Issues, "placeholder") {
-				t.Fatalf("Issues = %+v, want placeholder issue", report.Issues)
-			}
-		})
-	}
-}
-
-func TestValidateRunRejectsWrongNamespaceVisibleContent(t *testing.T) {
-	tests := []struct {
-		name string
-		body string
-	}{
-		{
-			name: "wrong namespace path",
-			body: `<bad:path xmlns:bad="https://wrong.example/svg" d="M10 10h20v20z"/>`,
-		},
-		{
-			name: "wrong namespace text",
-			body: `<bad:text xmlns:bad="https://wrong.example/svg">hidden by namespace</bad:text>`,
-		},
-		{
-			name: "wrong namespace image href",
-			body: `<image xmlns:bad="https://wrong.example/svg" bad:href="asset.png" width="120" height="80"/>`,
-		},
-		{
-			name: "wrong namespace viewBox",
-			body: `<text>hello</text>`,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			initValidateTestRun(t)
-			writeMinimalDeck(t, "demo", "slides/01.svg")
-			viewBox := `viewBox="0 0 960 540"`
-			if tt.name == "wrong namespace viewBox" {
-				viewBox = `bad:viewBox="0 0 960 540" xmlns:bad="https://wrong.example/svg"`
-			}
-			svg := `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" ` + viewBox + `>` + tt.body + `</svg>`
-			writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), svg)
-
-			report, err := ValidateRun("demo")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if report.OK {
-				t.Fatalf("OK = true, want false")
-			}
-			if tt.name == "wrong namespace viewBox" {
-				if !validationIssuesContain(report.Issues, "viewBox") {
-					t.Fatalf("Issues = %+v, want viewBox issue", report.Issues)
-				}
-				return
-			}
-			if !validationIssuesContain(report.Issues, "background") && !validationIssuesContain(report.Issues, "placeholder") {
-				t.Fatalf("Issues = %+v, want placeholder issue", report.Issues)
-			}
-		})
-	}
-}
-
-func TestValidateRunAcceptsNamespacedXLinkHref(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	svg := `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" xmlns:xlink="http://www.w3.org/1999/xlink" slide:role="slide" viewBox="0 0 960 540"><image xlink:href="asset.png" width="120" height="80"/></svg>`
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), svg)
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !report.OK {
-		t.Fatalf("OK = false, issues = %+v", report.Issues)
-	}
-}
-
-func TestValidateRunAcceptsPlainHref(t *testing.T) {
-	initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	svg := `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><image href="asset.png" width="120" height="80"/></svg>`
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), svg)
-
-	report, err := ValidateRun("demo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !report.OK {
-		t.Fatalf("OK = false, issues = %+v", report.Issues)
-	}
-}
-
-func TestValidateRunRejectsReceiptSymlink(t *testing.T) {
-	cwd := initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-	if err := os.RemoveAll(filepath.Join("demo", "receipts")); err != nil {
-		t.Fatal(err)
-	}
-	outside := filepath.Join(filepath.Dir(cwd), "outside-receipts")
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "receipts")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := ValidateRun("demo"); err == nil {
-		t.Fatal("expected receipt symlink write refusal")
-	}
-	if _, err := os.Stat(filepath.Join(outside, "lint.json")); !os.IsNotExist(err) {
-		t.Fatalf("lint receipt should not be written outside run root, stat err=%v", err)
-	}
-}
-
-func TestValidateRunRejectsLintReceiptFileSymlink(t *testing.T) {
-	cwd := initValidateTestRun(t)
-	writeMinimalDeck(t, "demo", "slides/01.svg")
-	writeValidateTestFile(t, filepath.Join("demo", "slides", "01.svg"), visibleTextSVG())
-	if err := os.Remove(filepath.Join("demo", "receipts", "lint.json")); err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	outside := filepath.Join(filepath.Dir(cwd), "outside-lint.json")
-	if err := os.WriteFile(outside, []byte("outside"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join("demo", "receipts", "lint.json")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := ValidateRun("demo"); err == nil {
-		t.Fatal("expected lint receipt file symlink write refusal")
-	}
-	raw, err := os.ReadFile(outside)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(raw) != "outside" {
-		t.Fatalf("outside file was overwritten: %q", string(raw))
-	}
-}
-
-func initValidateTestRun(t *testing.T) string {
-	t.Helper()
-	cwd := t.TempDir()
-	t.Chdir(cwd)
-	if err := os.WriteFile("source.md", []byte("# Demo"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := InitRun("demo", InitOptions{Title: "Demo", Input: "source.md"}); err != nil {
-		t.Fatal(err)
-	}
-	return cwd
-}
-
-func writeMinimalDeck(t *testing.T, root string, slidePaths ...string) {
-	t.Helper()
-	writeMinimalDeckAt(t, filepath.Join(root, "outline", "deck.json"), slidePaths...)
-}
-
-func writeMinimalDeckAt(t *testing.T, path string, slidePaths ...string) {
-	t.Helper()
-	slides := make([]map[string]string, 0, len(slidePaths))
-	for i, path := range slidePaths {
-		slides = append(slides, map[string]string{
-			"id":          "slide-" + string(rune('1'+i)),
-			"title":       "Slide",
-			"summary":     "Summary",
-			"role":        "content",
-			"key_message": "Message",
-			"path":        path,
-		})
-	}
-	raw, err := json.MarshalIndent(map[string]any{
-		"title":  "Demo",
-		"slides": slides,
-	}, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw = append(raw, '\n')
-	writeValidateTestFile(t, path, string(raw))
-}
-
-func readValidateTestRunFile(t *testing.T) Run {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("demo", "run.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var run Run
-	if err := json.Unmarshal(raw, &run); err != nil {
-		t.Fatal(err)
-	}
-	return run
-}
-
-func writeValidateTestRunFile(t *testing.T, run Run) {
-	t.Helper()
-	raw, err := json.MarshalIndent(run, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw = append(raw, '\n')
-	if err := os.WriteFile(filepath.Join("demo", "run.json"), raw, 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func writeValidateTestFile(t *testing.T, path string, content string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func backgroundOnlySVG() string {
-	return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><rect width="960" height="540" fill="#fff"/></svg>`
-}
-
-func visibleTextSVG() string {
-	return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><rect width="960" height="540" fill="#fff"/><text x="48" y="80">Hello</text></svg>`
-}
-
-func validationIssuesContain(issues []ValidationIssue, needle string) bool {
-	for _, issue := range issues {
-		if strings.Contains(issue.Path, needle) || strings.Contains(issue.Message, needle) {
-			return true
-		}
-	}
-	return false
-}
-
-func assertValidationFailureArtifacts(t *testing.T, root string, report ValidationReport, needle string) {
-	t.Helper()
-	if report.OK {
-		t.Fatalf("OK = true, want false")
-	}
-	if len(report.Issues) == 0 {
-		t.Fatal("expected validation issue")
-	}
-	if !validationIssuesContain(report.Issues, needle) {
-		t.Fatalf("Issues = %+v, want %q", report.Issues, needle)
-	}
-
-	raw, err := os.ReadFile(filepath.Join(root, "receipts", "lint.json"))
-	if err != nil {
-		t.Fatalf("missing lint receipt: %v", err)
-	}
-	var receipt ValidationReport
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatalf("lint receipt is not ValidationReport JSON: %v", err)
-	}
-	if receipt.OK || !validationIssuesContain(receipt.Issues, needle) {
-		t.Fatalf("lint receipt = %+v, want failing issue containing %q", receipt, needle)
-	}
-
-	queue, err := os.ReadFile(filepath.Join(root, "repair_queue.md"))
-	if err != nil {
-		t.Fatalf("missing repair queue: %v", err)
-	}
-	if !strings.Contains(string(queue), needle) {
-		t.Fatalf("repair queue = %q, want %q", string(queue), needle)
-	}
-}

internal/update/update.go

@@ -25,7 +25,7 @@ import (
 const (
 	registryURL  = "https://registry.npmjs.org/@larksuite/cli/latest"
 	cacheTTL     = 24 * time.Hour
-	fetchTimeout = 5 * time.Second
+	fetchTimeout = 15 * time.Second
 	stateFile    = "update-state.json"
 	maxBody      = 256 << 10 // 256 KB
 

internal/vfs/default.go

@@ -27,7 +27,6 @@ func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	return DefaultFS.OpenFile(name, flag, perm)
 }
 func CreateTemp(dir, pattern string) (*os.File, error) { return DefaultFS.CreateTemp(dir, pattern) }
-func Mkdir(path string, perm fs.FileMode) error        { return DefaultFS.Mkdir(path, perm) }
 func MkdirAll(path string, perm fs.FileMode) error     { return DefaultFS.MkdirAll(path, perm) }
 func MkdirTemp(dir, pattern string) (string, error)    { return DefaultFS.MkdirTemp(dir, pattern) }
 func ReadDir(name string) ([]os.DirEntry, error)       { return DefaultFS.ReadDir(name) }

internal/vfs/fs.go

@@ -25,7 +25,6 @@ type FS interface {
 	CreateTemp(dir, pattern string) (*os.File, error)
 
 	// Directory/File management
-	Mkdir(path string, perm fs.FileMode) error
 	MkdirAll(path string, perm fs.FileMode) error
 	MkdirTemp(dir, pattern string) (string, error)
 	ReadDir(name string) ([]os.DirEntry, error)

internal/vfs/osfs.go

@@ -30,7 +30,6 @@ func (OsFs) OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error)
 func (OsFs) CreateTemp(dir, pattern string) (*os.File, error) { return os.CreateTemp(dir, pattern) }
 
 // Directory/File management
-func (OsFs) Mkdir(path string, perm fs.FileMode) error     { return os.Mkdir(path, perm) }
 func (OsFs) MkdirAll(path string, perm fs.FileMode) error  { return os.MkdirAll(path, perm) }
 func (OsFs) MkdirTemp(dir, pattern string) (string, error) { return os.MkdirTemp(dir, pattern) }
 func (OsFs) ReadDir(name string) ([]os.DirEntry, error)    { return os.ReadDir(name) }

internal/vfs/osfs_test.go

@@ -23,15 +23,6 @@ func TestOsFsBasicOperations(t *testing.T) {
 	fs := OsFs{}
 	dir := t.TempDir()
 
-	// Mkdir
-	one := filepath.Join(dir, "one")
-	if err := fs.Mkdir(one, 0o755); err != nil {
-		t.Fatalf("Mkdir: %v", err)
-	}
-	if err := Mkdir(filepath.Join(dir, "two"), 0o755); err != nil {
-		t.Fatalf("package Mkdir: %v", err)
-	}
-
 	// MkdirAll
 	sub := filepath.Join(dir, "a", "b")
 	if err := fs.MkdirAll(sub, 0o755); err != nil {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.63",
+  "version": "1.0.64",
   "description": "The official CLI for Lark/Feishu open platform",
   "bin": {
     "lark-cli": "scripts/run.js"

shortcuts/doc/doc_media_upload.go

@@ -23,8 +23,8 @@ var DocMediaUpload = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "file", Desc: "local file path (files > 20MB use multipart upload automatically)", Required: true},
-		{Name: "parent-type", Desc: "parent type: docx_image | docx_file | whiteboard", Required: true},
-		{Name: "parent-node", Desc: "parent node ID (block_id for docx, board_token for whiteboard)", Required: true},
+		{Name: "parent-type", Desc: "parent type: docx_image | docx_file | whiteboard | mindnote_image", Required: true},
+		{Name: "parent-node", Desc: "parent node ID (block_id for docx, board_token for whiteboard, mindnote token for mindnote)", Required: true},
 		{Name: "doc-id", Desc: "document ID (for drive_route_token)"},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {

shortcuts/drive/drive_search.go

@@ -75,7 +75,7 @@ var DriveSearch = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	HasFormat:   true,
 	Flags: []common.Flag{
-		{Name: "query", Desc: "search keyword (may be empty to browse by filter only)"},
+		{Name: "query", Desc: "search keyword (may be empty to browse by filter only); max 30 characters by Unicode code point (CJK counts 1 each), over 30 the server rejects with 99992402 field validation failed"},
 
 		{Name: "mine", Type: "bool", Desc: "restrict to docs I own (server-side owner semantic, NOT original creator; uses current user's open_id)"},
 		{Name: "creator-ids", Desc: "comma-separated owner open_ids (API field is creator_ids but matched by owner); mutually exclusive with --mine"},

shortcuts/slides/shortcuts.go

@@ -9,7 +9,6 @@ import "github.com/larksuite/cli/shortcuts/common"
 func Shortcuts() []common.Shortcut {
 	return []common.Shortcut{
 		SlidesCreate,
-		SlidesCreateSVGlide,
 		SlidesMediaUpload,
 		SlidesReplaceSlide,
 		SlidesReplacePages,

shortcuts/slides/slides_create_svglide.go

@@ -1,135 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package slides
-
-import (
-	"context"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/svglide"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// SlidesCreateSVGlide manages a local Codex-mediated SVGlide SVG run directory.
-var SlidesCreateSVGlide = common.Shortcut{
-	Service:     "slides",
-	Command:     "+create-svglide",
-	Description: "Create and manage a local SVGlide SVG run directory",
-	Risk:        "write",
-	AuthTypes:   []string{"user", "bot"},
-	Flags: []common.Flag{
-		{Name: "action", Desc: "runtime action: init, status, next, complete, author, validate, preview, repair", Required: true, Enum: []string{"init", "status", "next", "complete", "author", "validate", "preview", "repair"}},
-		{Name: "run", Desc: "existing run directory for status/next/complete/author/validate/preview/repair"},
-		{Name: "title", Desc: "deck title for init"},
-		{Name: "input", Desc: "local source markdown/text path for init"},
-		{Name: "audience", Desc: "final audience for the deck"},
-		{Name: "delivery-mode", Desc: "delivery mode: presented, self_read, dual_mode", Enum: []string{"presented", "self_read", "dual_mode"}},
-		{Name: "pages", Type: "int", Desc: "target page count"},
-		{Name: "out", Desc: "output run directory for init"},
-		{Name: "overwrite", Type: "bool", Desc: "allow init to overwrite an existing run directory"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		action := runtime.Str("action")
-		if action == "init" {
-			if strings.TrimSpace(runtime.Str("title")) == "" {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--title is required for init").WithParam("--title")
-			}
-			if strings.TrimSpace(runtime.Str("input")) == "" {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--input is required for init").WithParam("--input")
-			}
-			if strings.TrimSpace(runtime.Str("out")) == "" {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--out is required for init").WithParam("--out")
-			}
-			if stat, err := runtime.FileIO().Stat(runtime.Str("input")); err != nil {
-				return common.WrapInputStatErrorTyped(err, "cannot read --input")
-			} else if !stat.Mode().IsRegular() {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--input must be a regular file").WithParam("--input")
-			}
-			return nil
-		}
-		if strings.TrimSpace(runtime.Str("run")) == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--run is required for %s", action).WithParam("--run")
-		}
-		return nil
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		action := runtime.Str("action")
-		switch action {
-		case "init":
-			out := runtime.Str("out")
-			if err := svglide.InitRun(out, svglide.InitOptions{
-				Title:        runtime.Str("title"),
-				Input:        runtime.Str("input"),
-				Audience:     runtime.Str("audience"),
-				DeliveryMode: runtime.Str("delivery-mode"),
-				Pages:        runtime.Int("pages"),
-				Overwrite:    runtime.Bool("overwrite"),
-			}); err != nil {
-				return err
-			}
-			status, err := svglide.InspectStatus(out)
-			if err != nil {
-				return err
-			}
-			runtime.Out(map[string]any{
-				"action":       action,
-				"run":          out,
-				"next_command": status.NextCommand,
-			}, nil)
-			return nil
-		case "status":
-			report, err := svglide.InspectStatus(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "next":
-			report, err := svglide.NextTask(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "complete":
-			report, err := svglide.CompleteCurrentStage(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "author":
-			report, err := svglide.AuthorSlides(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "validate":
-			report, err := svglide.ValidateRun(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "preview":
-			report, err := svglide.WritePreview(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		case "repair":
-			report, err := svglide.RepairRun(runtime.Str("run"))
-			if err != nil {
-				return err
-			}
-			runtime.Out(report, nil)
-			return nil
-		default:
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --action %q", action).WithParam("--action")
-		}
-	},
-}

shortcuts/slides/slides_create_svglide_test.go

@@ -1,381 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package slides
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func TestSlidesCreateSVGlideInitShortcut(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-	if err := os.WriteFile("source.md", []byte("# Demo"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "init",
-		"--title", "Demo",
-		"--input", "source.md",
-		"--audience", "产品负责人",
-		"--delivery-mode", "self_read",
-		"--pages", "8",
-		"--out", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "run-demo", "run.json")); err != nil {
-		t.Fatalf("missing run.json: %v", err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["action"] != "init" {
-		t.Fatalf("action = %v, want init", data["action"])
-	}
-	if data["run"] != "run-demo" {
-		t.Fatalf("run = %v, want run-demo", data["run"])
-	}
-	if !strings.Contains(stringValue(data["next_command"]), "--action next --run run-demo") {
-		t.Fatalf("next_command = %v, want next action", data["next_command"])
-	}
-}
-
-func TestSlidesCreateSVGlideRejectsPositionalAction(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"init",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected positional argument rejection")
-	}
-	if !strings.Contains(err.Error(), "positional arguments are not supported") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestSlidesCreateSVGlideStatusAndNextActions(t *testing.T) {
-	dir := initSVGlideShortcutRun(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "status",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	statusData := decodeShortcutData(t, stdout)
-	if statusData["current_stage"] != "request" {
-		t.Fatalf("current_stage = %v, want request", statusData["current_stage"])
-	}
-	if !strings.Contains(stringValue(statusData["next_command"]), "--action next --run run-demo") {
-		t.Fatalf("next_command = %v, want next action", statusData["next_command"])
-	}
-
-	err = runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "next",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	nextData := decodeShortcutData(t, stdout)
-	if nextData["stage"] != "request" || nextData["prompt_path"] != "prompts/01_request.task.md" {
-		t.Fatalf("next data = %+v, want request prompt", nextData)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "run-demo", "prompts", "01_request.task.md")); err != nil {
-		t.Fatalf("missing prompt: %v", err)
-	}
-}
-
-func TestSlidesCreateSVGlideValidateActionOutputsReport(t *testing.T) {
-	initSVGlideShortcutRunWithDeck(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "validate",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["ok"] != true {
-		t.Fatalf("ok = %v, want true; data=%+v", data["ok"], data)
-	}
-	if _, err := os.Stat(filepath.Join("run-demo", "receipts", "lint.json")); err != nil {
-		t.Fatalf("missing lint receipt: %v", err)
-	}
-}
-
-func TestSlidesCreateSVGlidePreviewActionOutputsReport(t *testing.T) {
-	initSVGlideShortcutRunWithDeck(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "preview",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["status"] != "passed" {
-		t.Fatalf("status = %v, want passed; data=%+v", data["status"], data)
-	}
-	if _, err := os.Stat(filepath.Join("run-demo", "preview.html")); err != nil {
-		t.Fatalf("missing preview.html: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join("run-demo", "receipts", "preview.json")); err != nil {
-		t.Fatalf("missing preview receipt: %v", err)
-	}
-}
-
-func TestSlidesCreateSVGlideActionEnumIncludesCompleteAuthorAndRepair(t *testing.T) {
-	actionFlag := findSVGlideShortcutFlag(t, "action")
-	want := map[string]bool{
-		"complete": false,
-		"author":   false,
-		"repair":   false,
-	}
-	for _, value := range actionFlag.Enum {
-		if _, ok := want[value]; ok {
-			want[value] = true
-		}
-	}
-	for value, found := range want {
-		if !found {
-			t.Fatalf("action enum missing %q: %+v", value, actionFlag.Enum)
-		}
-		if !strings.Contains(actionFlag.Desc, value) {
-			t.Fatalf("action desc %q missing %q", actionFlag.Desc, value)
-		}
-	}
-}
-
-func TestSlidesCreateSVGlideRepairActionAuthorsAndPreviews(t *testing.T) {
-	initSVGlideShortcutRunWithAuthorInputs(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "repair",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["status"] != "passed" {
-		t.Fatalf("status = %v, want passed; data=%+v", data["status"], data)
-	}
-	if data["reauthored"] != true {
-		t.Fatalf("reauthored = %v, want true; data=%+v", data["reauthored"], data)
-	}
-	if _, err := os.Stat(filepath.Join("run-demo", "preview.html")); err != nil {
-		t.Fatalf("missing preview.html: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join("run-demo", "receipts", "validate_preview_repair.json")); err != nil {
-		t.Fatalf("missing final repair receipt: %v", err)
-	}
-}
-
-func TestSlidesCreateSVGlideCompleteActionAdvancesRequestStage(t *testing.T) {
-	dir := initSVGlideShortcutRun(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "complete",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["current_stage"] != "research" {
-		t.Fatalf("current_stage = %v, want research; data=%+v", data["current_stage"], data)
-	}
-	receiptPath := filepath.Join(dir, "run-demo", "receipts", "request.json")
-	raw, err := os.ReadFile(receiptPath)
-	if err != nil {
-		t.Fatalf("missing request receipt: %v", err)
-	}
-	var receipt map[string]any
-	if err := json.Unmarshal(raw, &receipt); err != nil {
-		t.Fatalf("invalid request receipt: %v", err)
-	}
-	if receipt["stage"] != "request" || receipt["status"] != "done" {
-		t.Fatalf("receipt = %+v, want request done", receipt)
-	}
-}
-
-func TestSlidesCreateSVGlideAuthorActionWritesSVG(t *testing.T) {
-	initSVGlideShortcutRunWithAuthorInputs(t)
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "author",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["status"] != "done" {
-		t.Fatalf("status = %v, want done; data=%+v", data["status"], data)
-	}
-	raw, err := os.ReadFile(filepath.Join("run-demo", "slides", "01.svg"))
-	if err != nil {
-		t.Fatalf("missing authored SVG: %v", err)
-	}
-	if !strings.Contains(string(raw), `slide:role="slide"`) {
-		t.Fatalf("authored SVG missing slide role:\n%s", string(raw))
-	}
-}
-
-func TestSlidesCreateSVGlideValidateActionDoesNotErrorOnValidationFailure(t *testing.T) {
-	initSVGlideShortcutRun(t)
-	writeSVGlideShortcutDeck(t, "slides/missing.svg")
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "validate",
-		"--run", "run-demo",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	data := decodeShortcutData(t, stdout)
-	if data["ok"] != false {
-		t.Fatalf("ok = %v, want false; data=%+v", data["ok"], data)
-	}
-}
-
-func TestSlidesCreateSVGlideRegistered(t *testing.T) {
-	for _, shortcut := range Shortcuts() {
-		if shortcut.Command == "+create-svglide" {
-			return
-		}
-	}
-	t.Fatal("slides +create-svglide shortcut is not registered")
-}
-
-func initSVGlideShortcutRunWithDeck(t *testing.T) {
-	initSVGlideShortcutRun(t)
-	writeSVGlideShortcutDeck(t, "slides/01.svg")
-	writeSVGlideShortcutFile(t, filepath.Join("run-demo", "slides", "01.svg"), svglideShortcutVisibleTextSVG())
-}
-
-func initSVGlideShortcutRunWithAuthorInputs(t *testing.T) {
-	initSVGlideShortcutRun(t)
-	writeSVGlideShortcutDeck(t, "slides/01.svg")
-	writeSVGlideShortcutFile(t, filepath.Join("run-demo", "brief", "visual_system.json"), `{"color_system":{"background":"#FFFFFF","ink":"#111827","muted":"#6B7280","accent":"#2563EB"},"typography":{"title":32,"body":16},"layout_language":"analyst deck"}`)
-	writeSVGlideShortcutFile(t, filepath.Join("run-demo", "content", "slide_content.json"), `{"slides":[{"id":"cover","content":"Point A\nPoint B","notes":"Speaker note"}]}`)
-	writeSVGlideShortcutFile(t, filepath.Join("run-demo", "assets", "assets_plan.json"), `{"assets":[]}`)
-}
-
-func initSVGlideShortcutRun(t *testing.T) string {
-	t.Helper()
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-	if err := os.WriteFile("source.md", []byte("# Demo"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	if err := runSlidesShortcut(t, f, stdout, SlidesCreateSVGlide, []string{
-		"+create-svglide",
-		"--action", "init",
-		"--title", "Demo",
-		"--input", "source.md",
-		"--out", "run-demo",
-		"--as", "user",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	return dir
-}
-
-func findSVGlideShortcutFlag(t *testing.T, name string) common.Flag {
-	t.Helper()
-	for _, flag := range SlidesCreateSVGlide.Flags {
-		if flag.Name == name {
-			return flag
-		}
-	}
-	t.Fatalf("missing flag %q", name)
-	return common.Flag{}
-}
-
-func writeSVGlideShortcutDeck(t *testing.T, slidePath string) {
-	t.Helper()
-	deck := map[string]any{
-		"title": "Demo",
-		"slides": []map[string]string{{
-			"id":          "cover",
-			"title":       "Slide",
-			"summary":     "Summary",
-			"role":        "cover",
-			"key_message": "Message",
-			"path":        slidePath,
-		}},
-	}
-	raw, err := json.MarshalIndent(deck, "", "  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw = append(raw, '\n')
-	writeSVGlideShortcutFile(t, filepath.Join("run-demo", "outline", "deck.json"), string(raw))
-}
-
-func writeSVGlideShortcutFile(t *testing.T, path string, content string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func svglideShortcutVisibleTextSVG() string {
-	return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:slide="https://slides.bytedance.com/ns" slide:role="slide" viewBox="0 0 960 540"><rect width="960" height="540" fill="#fff"/><text x="48" y="80">Hello</text></svg>`
-}
-
-func stringValue(value any) string {
-	if text, ok := value.(string); ok {
-		return text
-	}
-	var b bytes.Buffer
-	_ = json.NewEncoder(&b).Encode(value)
-	return strings.TrimSpace(b.String())
-}

skills/lark-doc/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: lark-doc
 version: 2.0.0
-description: "飞书云文档（Docx / Wiki 文档）：读取和编辑飞书文档内容。当用户给出文档 URL 或 token，或需要查看、创建、编辑文档、插入或下载文档图片附件时使用。文档中嵌入的电子表格、多维表格、画板，先用本 skill 提取 token 再切到对应 skill。当用户给出 doubao.com 的 /docx/ 或 /wiki/ URL/token 时，也应直接使用本 skill；路由依据是 URL 路径模式和 token，而不是域名。不负责文档评论管理，也不负责表格或 Base 的数据操作。"
+description: "飞书云文档（Docx / Wiki 文档）：读取和编辑飞书文档内容。当用户给出文档 URL 或 token，或需要查看、创建、编辑文档、插入或下载文档图片附件时使用。文档中嵌入的电子表格、多维表格、画板，先用本 skill 提取 token 再切到对应 skill。当用户给出 doubao.com 的 /docx/ 或 /wiki/ URL/token 时，也应直接使用本 skill；路由依据是 URL 路径模式和 token，而不是域名。不负责文档评论管理，也不负责表格或 Base 的数据操作。当用户明确要操作飞书思维笔记时，也使用本 skill。"
 metadata:
   requires:
     bins: ["lark-cli"]
-  cliHelp: "lark-cli docs --help; lark-cli docs +create --help; lark-cli docs +fetch --help; lark-cli docs +update --help; lark-cli docs +resource-download --help; lark-cli docs +resource-update --help; lark-cli docs +resource-delete --help"
+  cliHelp: "lark-cli docs --help; lark-cli docs +create --help; lark-cli docs +fetch --help; lark-cli docs +update --help; lark-cli docs +resource-download --help; lark-cli docs +resource-update --help; lark-cli docs +resource-delete --help; lark-cli mindnotes nodes list --help; lark-cli mindnotes nodes create --help"
 ---
 
 # docs
@@ -45,6 +45,7 @@ lark-cli docs +update --doc "文档URL或token" --command append --content '<p>
 - 用户明确说"下载/更新/删除文档封面图" → 用 `lark-cli docs +resource-download/+resource-update/+resource-delete --type cover`
 - `resource-*` 目前仅支持 Docx 封面资源；其他图片、附件或素材请走 `+media-*`
 - 如果目标是画板/whiteboard/画板缩略图 → 只能用 `lark-cli docs +media-download --type whiteboard`（不要用 `+media-preview`）
+- 用户明确要操作思维笔记时；已有**思维笔记**，走 [思维笔记链路](references/lark-doc-mindnote.md)；新建**思维笔记**，走 [lark-doc-whiteboard](references/lark-doc-whiteboard.md)
 - 拿到 spreadsheet URL/token 后 → 切到 `lark-sheets` 做对象内部操作
 - 用户需要统计文档的**总字数 / 总字符数**（word count / character count）时，先读取 [`lark-doc-word-stat.md`](references/lark-doc-word-stat.md)，并按其中流程调用 [`scripts/doc_word_stat.py`](scripts/doc_word_stat.py)；统计口径以该脚本为准，不要改用其他方式自行计算。
 - 用户说"给文档加评论""查看评论""回复评论""给评论加/删除表情 reaction" → 切到 `lark-drive` 处理

skills/lark-doc/references/lark-doc-mindnote.md

@@ -0,0 +1,113 @@
+# 飞书思维笔记（Mindnote）
+
+> **前置条件：** 先阅读 [`../SKILL.md`](../SKILL.md) 和 [`../../lark-shared/SKILL.md`](../../lark-shared/SKILL.md) 了解认证、全局参数和路由规则。
+
+当用户要操作思维笔记时，入口属于 `lark-doc`，但实际执行命令使用 `lark-cli mindnotes nodes list/create`，不是 `docs +...`。
+
+> [!IMPORTANT]
+> 当前这条链路只支持**读取已有思维笔记**，以及在**已有思维笔记**里读取节点、创建子节点。
+> `mindnotes nodes create` 是新增/更新节点命令，**不是**新建一个新的思维笔记。
+> 如果用户要**新建思维笔记**，不要走本链路，改走 [lark-doc-whiteboard](lark-doc-whiteboard.md)。
+
+## 命令
+
+```bash
+# 先看命令帮助
+lark-cli mindnotes nodes list --help
+lark-cli mindnotes nodes create --help
+
+# 读取节点列表
+lark-cli mindnotes nodes list --mindnote-id "<mindnote_token>"
+
+# 创建子节点
+lark-cli mindnotes nodes create \
+  --mindnote-id "<mindnote_token>" \
+  --data '{"client_token":"<client_token>","nodes":[{"parent_id":"node_parent123","texts":[{"element_type":"text","text":{"content":"子节点内容"}}],"highlight":"yellow","finish":false}]}'
+
+# 更新已有节点
+lark-cli mindnotes nodes create \
+  --mindnote-id "<mindnote_token>" \
+  --data '{"client_token":"<client_token>","nodes":[{"node_id":"node_existing123","texts":[{"element_type":"text","text":{"content":"更新后的节点内容"}}],"highlight":"blue","finish":true}]}'
+```
+
+## 参数
+
+### `mindnotes nodes list`
+
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `--mindnote-id` | 是 | 思维笔记 token / 唯一标识 |
+
+返回重点：`data.nodes` 中常见字段有 `node_id`、`parent_id`、`texts`、`notes`、`images`、`finish`、`highlight`。
+
+### `mindnotes nodes create`
+
+命令参数：
+
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `--mindnote-id` | 是 | 思维笔记 token / 唯一标识 |
+| `--data` | 是 | JSON 请求体 |
+
+请求体字段：
+
+| 字段 | 必填 | 说明 |
+|------|------|------|
+| `client_token` | 否 | 幂等 token，建议写操作传入；推荐使用时间戳或 UUID |
+| `nodes` | 是 | 待创建或更新的节点数组 |
+| `nodes[].node_id` | 否 | 节点 ID；传入已有 `node_id` 时表示更新对应节点 |
+| `nodes[].parent_id` | 否 | 父节点 ID；创建子节点时传入 |
+| `nodes[].texts` | 否 | 节点正文富文本数组 |
+| `nodes[].notes` | 否 | 节点备注富文本数组 |
+| `nodes[].images` | 否 | 节点图片列表 |
+| `nodes[].highlight` | 否 | `red` / `yellow` / `pink` / `blue` / `cyan` / `olive` / `grey` |
+| `nodes[].finish` | 否 | 节点完成状态 |
+
+富文本字段 `texts` / `notes` 是元素数组。最常见的是：
+
+```json
+[{"element_type":"text","text":{"content":"节点内容"}}]
+```
+
+### 节点图片（`nodes[].images`）
+
+`nodes[].images` 接收的是**图片 token**，不是本地文件路径，也不是 URL。
+
+```bash
+# 先上传图片，拿到 token
+lark-cli docs +media-upload --file ./image.png --parent-type mindnote_image --parent-node <mindnote_token>
+
+# 再把 token 写进节点
+lark-cli mindnotes nodes create \
+  --mindnote-id "<mindnote_token>" \
+  --data '{"client_token":"<client_token>","nodes":[{"node_id":"node_existing123","images":[{"token":"canonical_token"}]}]}'
+```
+
+参数说明：
+
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `--file` | 是 | 本地图片路径 |
+| `--parent-type` | 是 | 上传目标类型；图片使用 `mindnote_image` |
+| `--parent-node` | 是 | 传 Mindnote 的 token |
+| `nodes[].images[].token` | 是 | 上传后返回的图片 token |
+
+## 推荐工作流
+
+1. 先判断用户目标是不是“新建一个思维笔记”。
+2. 如果是新建思维笔记，切到 [lark-doc-whiteboard](lark-doc-whiteboard.md)。
+3. 如果是操作已有思维笔记，先通过 token 类别判断。
+4. 确认是 **Mindnote** 后再拿到 `mindnote_id`。
+5. 先执行 `mindnotes nodes list`，确认目标 `parent_id`。
+6. 新增子节点时，在 `nodes[]` 里传 `parent_id`；更新已有节点时，在 `nodes[]` 里传已有 `node_id`。
+7. 再执行 `mindnotes nodes create`。
+8. 写操作优先带 `client_token`，推荐使用时间戳或 UUID，避免重试时重复创建或重复更新。
+
+> [!CAUTION]
+> `mindnotes nodes create` 是写操作。创建时确认插入位置，更新时确认 `node_id` 指向的就是目标节点。
+
+## 参考
+
+- [lark-doc-fetch](lark-doc-fetch.md) — 获取文档内容
+- [lark-doc-whiteboard](lark-doc-whiteboard.md) — 新建思维笔记走画板链路
+- [lark-shared](../../lark-shared/SKILL.md) — 认证和全局参数

skills/lark-drive/references/lark-drive-search.md

@@ -23,6 +23,8 @@
 > 错误：`lark-cli drive +search 方案`
 > `+search` 不接受位置参数；空 `--query` 或省略 `--query` 表示纯靠 filter 浏览（合法）。
 >
+> **`--query` 最长 30 个字符**：按字符数（Unicode 码点）算，中文每字算 1 个，与 ASCII 同口径；超过 30 会被服务端拒绝（`99992402 field validation failed`，**是报错不是截断**）。长关键词必须先压缩成核心实体 + 主题词（如把整句问题压成「项目名 + 主题」再搜），不要把整句原问塞进 `--query`。
+>
 > **列表型请求不要硬塞关键词**：如果用户只是要求"我这月创建的所有文档"、"最近半年我编辑过的文档"、"按类型分类统计"这类范围浏览 / 汇总请求，且没有给出标题片段或业务关键词，应使用 `--query ""` 搭配 `--created-by-me`、`--mine`、`--created-*`、`--edited-*`、`--doc-types` 等过滤条件。不要把"查找"、"所有文档"、"最近更新过"、"按类型分类统计"这类动作词或统计意图放进 `--query`，否则会把本来应靠 filter 命中的结果过度收窄。
 
 ### 自然语言 → 命令映射速查
@@ -101,7 +103,7 @@ lark-cli drive +search --query 方案 --page-token '<PAGE_TOKEN>'
 
 | 参数 | 必填 | 说明 |
 |---|---|---|
-| `--query <text>` | 否 | 搜索关键词；支持服务端高级语法（`intitle:`、`""`、`OR`、`-`）。空字符串或省略表示纯 filter 浏览 |
+| `--query <text>` | 否 | 搜索关键词；支持服务端高级语法（`intitle:`、`""`、`OR`、`-`）。空字符串或省略表示纯 filter 浏览。**长度上限 30 个字符（按 Unicode 码点算，中文每字算 1 个，与 ASCII 同口径）；超过 30 服务端直接报 `99992402 field validation failed`，不会截断** |
 | `--page-size <n>` | 否 | 每页数量，默认 15，最大 20。超过 20 自动 clamp；非正数（≤0）回落 15；**非数字值直接返回 validation 错误** |
 | `--page-token <token>` | 否 | 上一次响应里的 `page_token`，用于翻页 |
 | `--format` | 否 | `json`（默认）/ `pretty` |

skills/lark-slides/SKILL.md

@@ -20,7 +20,6 @@ metadata:
 | 读取或分析已有 PPT | 解析 slides/wiki token，回读全文或单页 XML，保存 `xml_presentation_id`、`slide_id`、`revision_id` | `xml_presentations.get`、`xml_presentation.slide.get` |
 | 获取幻灯片页面截图 | 用 `slide_id` 或页号指定页面 | `slides +screenshot`、`lark-slides-screenshot.md` |
 | 上传或使用图片 | 先上传为 `file_token`，禁止直接写 http(s) 外链 | `slides +media-upload`，或 `+create --slides` 的 `@./path` 占位符 |
-| 使用 AnyGen SVG Slides 本地工作台 | 创建 run-dir，按 stage 填产物；本地校验/预览/修复，不发布飞书 | [`lark-slides-create-svglide.md`](references/lark-slides-create-svglide.md)、`slides +create-svglide` |
 | 在 slide 中绘制柱/条/折线/面积/雷达/饼等有数据序列的图表 | 使用原生 `<chart>` 元素 | `xml-schema-quick-ref.md` |
 | 在 slide 中绘制流程图、时序图、架构图、散点图、漏斗图或装饰图案 | 必须先用 Read 工具读取参考文档，再生成 `<whiteboard>` 元素 | [`lark-slides-whiteboard.md`](references/lark-slides-whiteboard.md) |
 | 使用语义图标 | 先检索 IconPark，再写 `<icon iconType="...">` | `iconpark_tool.py search → resolve`、`iconpark.md` |
@@ -80,7 +79,6 @@ lark-cli auth login --domain slides
 - 编辑：[`lark-slides-edit-workflows.md`](references/lark-slides-edit-workflows.md)、[`lark-slides-replace-slide.md`](references/lark-slides-replace-slide.md)、[`lark-slides-replace-pages.md`](references/lark-slides-replace-pages.md)
 - 截图：[`lark-slides-screenshot.md`](references/lark-slides-screenshot.md)
 - 图片：[`lark-slides-media-upload.md`](references/lark-slides-media-upload.md)
-- 本地 AnyGen SVG Slides 工作台：[`lark-slides-create-svglide.md`](references/lark-slides-create-svglide.md)
 - 流程图 / 时序图 / 架构图 / 装饰图案：[`lark-slides-whiteboard.md`](references/lark-slides-whiteboard.md)
 - 图标：[`iconpark.md`](references/iconpark.md)、[`scripts/iconpark_tool.py`](scripts/iconpark_tool.py)
 - 排障：[`troubleshooting.md`](references/troubleshooting.md)
@@ -249,7 +247,6 @@ Shortcut 是对常用操作的高级封装（`lark-cli slides +<verb> [flags]`
 | Shortcut | 说明 |
 |----------|------|
 | [`+create`](references/lark-slides-create.md) | 创建 PPT（可选 `--slides` 一步添加页面，支持 `<img src="@./local.png">` 占位符自动上传） |
-| [`+create-svglide`](references/lark-slides-create-svglide.md) | 创建和管理本地 SVGlide SVG run-dir，不发布到飞书，不调用 slide_engine |
 | [`+media-upload`](references/lark-slides-media-upload.md) | 上传本地图片到指定演示文稿，返回 `file_token`（用作 `<img src="...">`），最大 20 MB |
 | [`+replace-slide`](references/lark-slides-replace-slide.md) | 对已有幻灯片页面进行块级替换/插入（`block_replace` / `block_insert`），自动注入 id 和 `<content/>`，不改变页序 |
 | [`+replace-pages`](references/lark-slides-replace-pages.md) | 在原演示文稿内批量重建多个页面：先创建新页到旧页前，再删除旧页；适合已有 Slides 的多页大改，不新建链接 |

skills/lark-slides/references/lark-slides-create-svglide.md

@@ -1,130 +0,0 @@
-# slides +create-svglide
-
-`slides +create-svglide` 是本地 SVGlide SVG Slides 运行目录工作台。第一版只创建和管理本地 run-dir，不创建在线飞书幻灯片，不调用 `slide_engine`，不做 SVG-to-SXSD 发布。
-
-## 推荐流程
-
-初始化 run-dir：
-
-```bash
-lark-cli slides +create-svglide \
-  --as user \
-  --action init \
-  --title "Demo" \
-  --input ./source.md \
-  --audience "产品负责人" \
-  --delivery-mode self_read \
-  --pages 8 \
-  --out ./.lark-slides/svglide-runs/demo
-```
-
-查看下一步：
-
-```bash
-lark-cli slides +create-svglide --as user --action status --run ./.lark-slides/svglide-runs/demo
-lark-cli slides +create-svglide --as user --action next --run ./.lark-slides/svglide-runs/demo
-```
-
-每个 stage 的循环：
-
-```bash
-lark-cli slides +create-svglide --as user --action next --run ./.lark-slides/svglide-runs/demo
-# Codex 根据返回的 prompt 填充当前 stage outputs
-lark-cli slides +create-svglide --as user --action complete --run ./.lark-slides/svglide-runs/demo
-lark-cli slides +create-svglide --as user --action next --run ./.lark-slides/svglide-runs/demo
-```
-
-`outline`、`content`、`visual`、`assets` 就绪后，再生成基础文本 SVG：
-
-```bash
-lark-cli slides +create-svglide --as user --action author --run ./.lark-slides/svglide-runs/demo
-```
-
-最终校验和预览：
-
-```bash
-lark-cli slides +create-svglide --as user --action repair --run ./.lark-slides/svglide-runs/demo
-```
-
-必要时可单独定位校验或预览问题：
-
-```bash
-lark-cli slides +create-svglide --as user --action validate --run ./.lark-slides/svglide-runs/demo
-lark-cli slides +create-svglide --as user --action preview --run ./.lark-slides/svglide-runs/demo
-```
-
-`init` 只建立目录、`run.json`、prompt、schema 和 request 产物。Codex 按 `next` 返回的 prompt 填充当前 stage 产物后，用 `complete` 校验并推进 stage。`repair` 会先执行 validate；只有 lint 失败且失败项可由基础 `author` 覆盖修复时才会重新 author，再生成 preview。deck 缺失、JSON 错误等不可自动修复的问题会保留在 `receipts/lint.json` 和 `repair_queue.md`，由 Codex 手动修复后再运行校验。
-
-## Action
-
-| Action | 作用 | 主要产物 |
-|--------|------|----------|
-| `init` | 创建本地 run-dir | `run.json`、`request/request.json`、`prompts/*.task.md`、`schemas/*.json` |
-| `status` | 查看当前 stage、缺失输入/输出和下一条命令 | JSON 状态报告 |
-| `next` | 返回当前 stage 的 prompt、输入和输出列表 | JSON task 报告 |
-| `complete` | 校验当前 stage 输出并推进到下一 stage | `run.json`、`receipts/<stage>.json` |
-| `author` | 基于 deck/content/visual/assets 生成基础文本 SVG | `slides/*.svg`、`receipts/svg_author.json` |
-| `validate` | 校验 `outline/deck.json` 中的 `slides/*.svg` | `receipts/lint.json`、`repair_queue.md` |
-| `preview` | 生成本地 HTML 预览 | `preview.html`、`receipts/preview.json` |
-| `repair` | 执行 validate；仅在 lint 失败且可由基础 author 覆盖修复时重新 author，再 preview | `receipts/validate_preview_repair.json` |
-
-## 运行目录
-
-核心文件：
-
-- `run.json`
-- `request/request.json`
-- `request/source_manifest.json`
-- `research/research_notes.md`
-- `research/sources.json`
-- `brief/design_brief.json`
-- `brief/visual_system.json`
-- `outline/deck.json`
-- `content/slide_content.md`
-- `content/slide_content.json`
-- `assets/assets_plan.json`
-- `slides/*.svg`
-- `receipts/*.json`
-- `repair_queue.md`
-- `preview.html`
-
-## 边界
-
-- CLI 负责 run-dir 骨架、prompt/schema、状态检查、SVG lint、repair queue 和 HTML preview。
-- Codex 负责自动研究、设计 brief、slide content、资产规划、生图/搜图结果落地、SVG authoring 和修复。
-- 第一批功能等价适配不实现 chart、table、图片裁剪。遇到真实数据图表、表格或图片构图需求时，Codex 在内容层保留语义说明，CLI 基础 `author` 用文本和形状占位表达，不伪装成 native chart、native table 或 image crop。
-- 本命令不发布到 Feishu，不返回 `xml_presentation_id`，不创建 `.slides`，不调用 Slides OpenAPI。
-- `preview` 只允许 deck slide path 使用 `slides/<file>.svg` 单层本地路径；不要引用远程 URL、上级目录、百分号编码路径或嵌套目录。
-- `validate` 的 `ok=false` 表示内容校验失败，但命令仍会输出结构化报告；只有 run-dir 读取或本地写入失败才是命令异常。
-
-## Codex 执行规则
-
-1. 先运行 `status` 或 `next`，确认当前 stage 和缺失产物。
-2. 按 `prompts/*.task.md` 填充当前 stage 的输出，不跳 stage 写最终 SVG。
-3. 每个 stage 输出就绪后运行 `complete`，让 CLI 校验当前 stage 并推进 `run.json`。
-4. 当 `outline`、`content`、`visual`、`assets` 已存在时，可运行 `author` 生成基础文本 SVG。
-5. 生成 SVG 时保持纯 SVG、`viewBox="0 0 960 540"`、可选中文本、无远程资源。
-6. 最后运行 `repair`，形成 validate + preview + final receipt；`repair` 只自动处理可由基础 `author` 覆盖的 lint 失败，deck 缺失、JSON 错误等问题会保留 `receipts/lint.json` / `repair_queue.md` 供 Codex 手动修复。
-7. 不要把这个本地工作台描述成完整 12-agent 自动化系统；它是 Codex 协作的分阶段本地 runtime。
-
-## 常见命令
-
-```bash
-# 查看下一步该做什么
-lark-cli slides +create-svglide --as user --action next --run ./.lark-slides/svglide-runs/demo
-
-# 校验当前 stage 并推进
-lark-cli slides +create-svglide --as user --action complete --run ./.lark-slides/svglide-runs/demo
-
-# 基于已完成的 deck/content/visual/assets 生成基础文本 SVG
-lark-cli slides +create-svglide --as user --action author --run ./.lark-slides/svglide-runs/demo
-
-# 只做 SVG 协议校验
-lark-cli slides +create-svglide --as user --action validate --run ./.lark-slides/svglide-runs/demo
-
-# 生成本地预览
-lark-cli slides +create-svglide --as user --action preview --run ./.lark-slides/svglide-runs/demo
-
-# 执行 validate，必要时重新 author，再生成 preview
-lark-cli slides +create-svglide --as user --action repair --run ./.lark-slides/svglide-runs/demo
-```