@lingjingai/scriptctl 0.27.2 → 0.28.0

package/dist/usecases/direct.js

@@ -171,6 +171,29 @@ function readBatchResult(dir, batch) {
         return null;
     }
 }
+function isDirectStageName(value) {
+    switch (value) {
+        case "source_prepare":
+        case "episode_plan":
+        case "batch_plan":
+        case "episode_titles":
+        case "batch_extract":
+        case "episode_merge":
+        case "episode_synopsis":
+        case "script_merge":
+        case "asset_curation":
+        case "metadata_extract":
+        case "script_synopsis":
+        case "validate":
+            return true;
+        default:
+            return false;
+    }
+}
+let progressFrame = 0;
+let activeProgressFrame = null;
+let progressTimer = null;
+let progressBlockLines = 0;
 // Single source of truth for a batch's on-disk state, shared by init (what to
 // (re)run) and status (what to report) so the two can never disagree. "done"
 // requires a result that actually PARSES — a present-but-corrupt result is
@@ -182,6 +205,579 @@ function classifyBatch(dir, batch) {
         return "error";
     return "pending";
 }
+function statusFromBatchState(state) {
+    return state === "done" ? "success" : state;
+}
+function stageSnapshot(name, status, completed, total, message) {
+    const boundedTotal = Math.max(0, total);
+    const boundedCompleted = Math.max(0, Math.min(completed, boundedTotal));
+    const percent = boundedTotal > 0 ? Math.round((boundedCompleted / boundedTotal) * 100) : status === "success" ? 100 : 0;
+    return {
+        name,
+        status,
+        completed: boundedCompleted,
+        total: boundedTotal,
+        percent,
+        pending: status === "skipped" ? 0 : Math.max(0, boundedTotal - boundedCompleted),
+        warning: status === "warning" ? 1 : 0,
+        error: status === "error" ? 1 : 0,
+        message: message ?? "",
+    };
+}
+function fileStage(name, filePath, runningStage) {
+    if (exists(filePath))
+        return stageSnapshot(name, "success", 1, 1);
+    return stageSnapshot(name, runningStage === name ? "running" : "pending", 0, 1);
+}
+function readJsonFile(filePath, fallback) {
+    if (!exists(filePath))
+        return fallback;
+    return readJson(filePath);
+}
+function readableJsonFile(filePath) {
+    if (!exists(filePath))
+        return false;
+    try {
+        readJson(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function stageUnit(name) {
+    if (name === "batch_extract")
+        return "progress";
+    if (name === "episode_merge" || name === "episode_synopsis" || name === "episode_titles")
+        return "items";
+    return "step";
+}
+function stageLabel(name) {
+    switch (name) {
+        case "source_prepare": return "准备素材";
+        case "episode_plan": return "阅读剧本";
+        case "batch_plan": return "理解剧情";
+        case "episode_titles": return "整理内容";
+        case "batch_extract": return "整理内容";
+        case "episode_merge": return "生成剧本";
+        case "episode_synopsis": return "补充信息";
+        case "script_merge": return "生成剧本";
+        case "asset_curation": return "补充信息";
+        case "metadata_extract": return "补充信息";
+        case "script_synopsis": return "补充信息";
+        case "validate": return "检查结果";
+    }
+}
+function statusText(status) {
+    switch (status) {
+        case "success": return "完成";
+        case "running": return "进行中";
+        case "pending": return "等待中";
+        case "warning": return "需留意";
+        case "error": return "出错";
+        case "skipped": return "已跳过";
+    }
+}
+function statusPriority(status) {
+    switch (status) {
+        case "error": return 5;
+        case "warning": return 4;
+        case "running": return 3;
+        case "pending": return 2;
+        case "skipped": return 1;
+        default: return 0;
+    }
+}
+function userStageRows(stages) {
+    const byLabel = new Map();
+    for (const stage of stages) {
+        const label = stageLabel(stage.name);
+        byLabel.set(label, [...(byLabel.get(label) ?? []), stage]);
+    }
+    const rows = [];
+    for (const items of byLabel.values()) {
+        const total = items.reduce((sum, item) => sum + stageWeight(item.name), 0);
+        const completed = items.reduce((sum, item) => sum + stageWeight(item.name) * (item.status === "skipped" ? 1 : item.percent / 100), 0);
+        const status = items.reduce((max, item) => statusPriority(item.status) > statusPriority(max) ? item.status : max, "success");
+        rows.push({
+            name: items[0].name,
+            status,
+            completed: Math.round(completed),
+            total,
+            percent: total > 0 ? Math.round((completed / total) * 100) : 0,
+            pending: items.reduce((sum, item) => sum + item.pending, 0),
+            warning: items.reduce((sum, item) => sum + item.warning, 0),
+            error: items.reduce((sum, item) => sum + item.error, 0),
+            message: items.map((item) => item.message).filter(Boolean).join("; "),
+        });
+    }
+    return rows;
+}
+function stageWeight(name) {
+    switch (name) {
+        case "source_prepare": return 3;
+        case "episode_plan": return 7;
+        case "batch_plan": return 5;
+        case "episode_titles": return 5;
+        case "batch_extract": return 45;
+        case "episode_merge": return 8;
+        case "episode_synopsis": return 5;
+        case "script_merge": return 7;
+        case "asset_curation": return 5;
+        case "metadata_extract": return 3;
+        case "script_synopsis": return 5;
+        case "validate": return 2;
+    }
+}
+function snapshotProgressPercent(stages) {
+    let done = 0;
+    let total = 0;
+    for (const stage of stages) {
+        const weight = stageWeight(stage.name);
+        total += weight;
+        done += weight * (stage.status === "skipped" ? 1 : stage.percent / 100);
+    }
+    return total > 0 ? Math.max(0, Math.min(100, Math.round((done / total) * 100))) : 0;
+}
+function useProgressColor() {
+    return Boolean(process.stderr.isTTY) && process.env.NO_COLOR === undefined;
+}
+function ansi(code, text) {
+    return useProgressColor() ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+function colorStatus(status, text) {
+    switch (status) {
+        case "success": return ansi(32, text);
+        case "error": return ansi(31, text);
+        case "warning": return ansi(33, text);
+        case "running": return ansi(36, text);
+        case "pending": return ansi(34, text);
+        case "skipped": return ansi(90, text);
+    }
+}
+function dim(text) {
+    return ansi(2, text);
+}
+function bold(text) {
+    return ansi(1, text);
+}
+function progressBar(stage) {
+    const width = 24;
+    const ratio = stage.percent / 100;
+    const filled = Math.round(ratio * width);
+    const bar = `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+    return colorStatus(stage.status, bar);
+}
+function statusMark(stage) {
+    if (stage.status === "running") {
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        const frame = frames[progressFrame % frames.length];
+        progressFrame += 1;
+        return ansi(36, frame);
+    }
+    if (stage.status === "success")
+        return ansi(32, "✓");
+    if (stage.status === "error")
+        return ansi(31, "✖");
+    if (stage.status === "warning")
+        return ansi(33, "!");
+    if (stage.status === "skipped")
+        return ansi(90, "-");
+    return ansi(34, "•");
+}
+function renderProgressLine(stage) {
+    const status = colorStatus(stage.status, stage.status.padEnd(7));
+    const percent = `${stage.percent}%`;
+    const bits = [
+        statusMark(stage),
+        bold(stageLabel(stage.name)),
+        status,
+        progressBar(stage),
+        `${percent} ${stageUnit(stage.name)}`,
+    ];
+    if (stage.error > 0)
+        bits.push(ansi(31, `error ${stage.error}`));
+    if (stage.warning > 0)
+        bits.push(ansi(33, `warning ${stage.warning}`));
+    if (stage.status === "pending")
+        bits.push(ansi(34, statusText("pending")));
+    if (stage.message)
+        bits.push(dim(`- ${stage.message}`));
+    return bits.join(" ");
+}
+function renderStageDetail(stage) {
+    const counts = [`${stage.percent}%`];
+    if (stage.error > 0)
+        counts.push(ansi(31, `error ${stage.error}`));
+    if (stage.warning > 0)
+        counts.push(ansi(33, `warning ${stage.warning}`));
+    if (stage.status === "pending")
+        counts.push(ansi(34, statusText("pending")));
+    return `  ${dim("stage")} ${stageLabel(stage.name)} ${colorStatus(stage.status, statusText(stage.status))} ${counts.join(", ")}`;
+}
+function renderEpisodeDetail(episode) {
+    const percent = episode.batches_total > 0 ? Math.round((episode.batches_done / episode.batches_total) * 100) : 0;
+    const errors = episode.error_batches.length > 0 ? ansi(31, " has errors") : "";
+    return `  ${dim("episode")} ${episode.episode_id} ${colorStatus(episode.status, statusText(episode.status))} ${percent}%, story ${colorStatus(episode.synopsis_status, statusText(episode.synopsis_status))}${errors}`;
+}
+function renderBatchDetail(batch) {
+    const reason = batch.error_code || batch.error_type || batch.message;
+    return `  ${dim("detail")} ${batch.batch_id} ${colorStatus(batch.status, statusText(batch.status))} ep_${pad3(batch.episode)}${reason ? ` - ${reason}` : ""}`;
+}
+function capDetails(lines, total, label) {
+    if (total <= lines.length)
+        return lines;
+    return [...lines, `  ${dim(`${total - lines.length} more ${label}`)}`];
+}
+function renderProgressDetails(snapshot, stageName) {
+    if (stageName === "batch_extract") {
+        const episodes = snapshot.episodes.filter((episode) => episode.status !== "success");
+        return [
+            ...capDetails(episodes.slice(0, 4).map((episode) => renderEpisodeDetail(episode)), episodes.length, "episodes"),
+        ];
+    }
+    if (stageName === "episode_titles" || stageName === "episode_merge" || stageName === "episode_synopsis") {
+        const episodes = snapshot.episodes.filter((episode) => episode.status !== "success" || episode.synopsis_status !== "success");
+        return capDetails(episodes.slice(0, 6).map((episode) => renderEpisodeDetail(episode)), episodes.length, "episodes");
+    }
+    const stages = snapshot.stages.filter((stage) => stage.status === "running" || stage.status === "pending" || stage.status === "warning" || stage.status === "error");
+    return capDetails(stages.slice(0, 5).map((stage) => renderStageDetail(stage)), stages.length, "stages");
+}
+function renderProgressFrameText(frame) {
+    return [renderProgressLine(frame.stage), ...frame.details].join("\n");
+}
+function renderProgressFrame() {
+    if (activeProgressFrame)
+        updateProgressBlock(renderProgressFrameText(activeProgressFrame));
+}
+function progressStageWithStatus(stage, status) {
+    if (status === "success")
+        return { ...stage, status, completed: stage.total, percent: 100, pending: 0, warning: 0, error: 0 };
+    if (status === "warning")
+        return { ...stage, status, completed: stage.total, percent: 100, pending: 0, warning: Math.max(1, stage.warning), error: 0 };
+    if (status === "skipped")
+        return { ...stage, status, percent: 100, pending: 0, warning: 0, error: 0 };
+    if (status === "error")
+        return { ...stage, status, error: Math.max(1, stage.error) };
+    return { ...stage, status };
+}
+function stopProgressTimer() {
+    if (!progressTimer)
+        return;
+    clearInterval(progressTimer);
+    progressTimer = null;
+}
+function ensureProgressTimer() {
+    if (!process.stderr.isTTY || progressTimer !== null)
+        return;
+    progressTimer = setInterval(renderProgressFrame, 80);
+}
+function eraseProgressBlock() {
+    if (progressBlockLines === 0)
+        return;
+    process.stderr.write(`\x1b[${progressBlockLines}A`);
+    for (let i = 0; i < progressBlockLines; i++) {
+        process.stderr.write("\x1b[2K");
+        if (i < progressBlockLines - 1)
+            process.stderr.write("\x1b[1B");
+    }
+    process.stderr.write("\r");
+    if (progressBlockLines > 1)
+        process.stderr.write(`\x1b[${progressBlockLines - 1}A`);
+    progressBlockLines = 0;
+}
+function updateProgressBlock(text) {
+    eraseProgressBlock();
+    process.stderr.write(text + "\n");
+    progressBlockLines = text.split("\n").length;
+}
+function persistProgressLine(text) {
+    eraseProgressBlock();
+    process.stderr.write(text + "\n");
+}
+function emitProgressStage(stage, details = []) {
+    const line = renderProgressLine(stage);
+    if (!process.stderr.isTTY) {
+        process.stderr.write(line + "\n");
+        return;
+    }
+    activeProgressFrame = { stage, details: stage.status === "running" ? details : [] };
+    if (stage.status === "running") {
+        ensureProgressTimer();
+        updateProgressBlock(renderProgressFrameText(activeProgressFrame));
+        return;
+    }
+    stopProgressTimer();
+    persistProgressLine(line);
+    activeProgressFrame = null;
+}
+function finishInitProgress() {
+    stopProgressTimer();
+    if (process.stderr.isTTY)
+        eraseProgressBlock();
+}
+function emitInitProgress(workspace, stageName, fallbackStatus = "running") {
+    const dd = directDir(workspace);
+    const episodePlanPath = path.join(dd, "episode_plan.json");
+    const batchPlanPath = path.join(dd, "batch_plan.json");
+    if (exists(episodePlanPath) && exists(batchPlanPath)) {
+        const snapshot = buildDirectStatusSnapshot(workspace);
+        const stage = snapshot.stages.find((item) => item.name === stageName);
+        if (stage) {
+            const renderedStage = fallbackStatus === "running" ? stage : progressStageWithStatus(stage, fallbackStatus);
+            emitProgressStage(renderedStage, renderProgressDetails(snapshot, stageName));
+            return;
+        }
+    }
+    emitProgressStage({
+        name: stageName,
+        status: fallbackStatus,
+        completed: fallbackStatus === "success" ? 1 : 0,
+        total: 1,
+        percent: fallbackStatus === "success" ? 100 : 0,
+        pending: fallbackStatus === "running" || fallbackStatus === "pending" ? 1 : 0,
+        warning: fallbackStatus === "warning" ? 1 : 0,
+        error: fallbackStatus === "error" ? 1 : 0,
+        message: "",
+    });
+}
+function emitFailedInitProgress(workspace) {
+    const stage = strOf(readRunState(workspace)["init_stage"]);
+    if (isDirectStageName(stage))
+        emitInitProgress(workspace, stage, "error");
+}
+function buildDirectStatusSnapshot(workspace) {
+    const dd = directDir(workspace);
+    const episodePlanPath = path.join(dd, "episode_plan.json");
+    const batchPlanPath = path.join(dd, "batch_plan.json");
+    const episodePlan = readJsonFile(episodePlanPath, {});
+    const batchPlan = readJsonFile(batchPlanPath, {});
+    const episodes = asList(episodePlan["episodes"]);
+    const batches = asList(batchPlan["batches"]);
+    const state = readRunState(workspace);
+    const rawRunningStage = strOf(state["init_stage"]);
+    const runningStage = rawRunningStage && rawRunningStage !== "complete" ? rawRunningStage : null;
+    const runStatus = strOf(state["status"]);
+    const failedStage = runStatus === "init_failed" ? runningStage : null;
+    const batchResultsDir = path.join(dd, "batch_results");
+    const episodeResultsDir = path.join(dd, "episode_results");
+    const batchesByEpisode = new Map();
+    const batchDetails = [];
+    let doneBatches = 0;
+    let errorBatches = 0;
+    for (const batch of batches) {
+        const batchId = batchResultKey(batch);
+        const status = statusFromBatchState(classifyBatch(batchResultsDir, batch));
+        if (status === "success")
+            doneBatches++;
+        if (status === "error")
+            errorBatches++;
+        const detail = {
+            batch_id: batchId,
+            episode: Number(batch["episode"]),
+            part: Number(batch["part"] ?? 0),
+            status,
+        };
+        if (status === "error") {
+            try {
+                const err = readJson(batchErrorPath(batchResultsDir, batch));
+                const errorCode = strOf(err["error_code"]);
+                const errorType = strOf(err["error_type"]);
+                const message = strOf(err["message"]);
+                if (errorCode)
+                    detail.error_code = errorCode;
+                if (errorType)
+                    detail.error_type = errorType;
+                if (message)
+                    detail.message = message;
+            }
+            catch {
+                detail.error_type = "Error";
+            }
+        }
+        batchDetails.push(detail);
+        if (!batchesByEpisode.has(detail.episode))
+            batchesByEpisode.set(detail.episode, []);
+        batchesByEpisode.get(detail.episode).push(detail);
+    }
+    const pendingBatches = batches.length - doneBatches - errorBatches;
+    const degradedSynopsisEpisodes = new Set(asList(state["summary_degraded_episodes"]).map((n) => Number(n)));
+    const episodeSnapshots = [];
+    let completeEpisodes = 0;
+    let episodeResults = 0;
+    let episodeSynopses = 0;
+    for (const episode of episodes) {
+        const episodeNum = Number(episode["episode"]);
+        const epBatches = batchesByEpisode.get(episodeNum) ?? [];
+        const batchesDone = epBatches.filter((b) => b.status === "success").length;
+        const batchesError = epBatches.filter((b) => b.status === "error").length;
+        const batchesPending = epBatches.length - batchesDone - batchesError;
+        const epResultPath = episodeResultPath(episodeResultsDir, episode);
+        const hasEpisodeResult = readableJsonFile(epResultPath);
+        if (hasEpisodeResult)
+            episodeResults++;
+        const synopsis = readEpisodeSynopsis(episodeResultsDir, episode);
+        if (synopsis)
+            episodeSynopses++;
+        const status = batchesError > 0
+            ? "error"
+            : epBatches.length > 0 && batchesDone === epBatches.length && hasEpisodeResult
+                ? "success"
+                : runningStage === "batch_extract" || runningStage === "episode_merge"
+                    ? "running"
+                    : "pending";
+        if (status === "success")
+            completeEpisodes++;
+        const synopsisStatus = degradedSynopsisEpisodes.has(episodeNum)
+            ? "warning"
+            : synopsis
+                ? "success"
+                : Boolean(state["summary_skipped"]) && !exists(path.join(dd, "synopsis.json"))
+                    ? "skipped"
+                    : "pending";
+        episodeSnapshots.push({
+            episode: episodeNum,
+            episode_id: episodeResultKey(episode),
+            status,
+            batches_done: batchesDone,
+            batches_total: epBatches.length,
+            batches_error: batchesError,
+            batches_pending: batchesPending,
+            synopsis_status: synopsisStatus,
+            error_batches: epBatches.filter((b) => b.status === "error").map((b) => b.batch_id),
+        });
+    }
+    const sourceStage = exists(path.join(workspace, "source.txt"))
+        ? stageSnapshot("source_prepare", "success", 1, 1)
+        : stageSnapshot("source_prepare", runningStage === "source_prepare" ? "running" : "pending", 0, 1);
+    const episodePlanStage = episodes.length > 0
+        ? stageSnapshot("episode_plan", "success", episodes.length, episodes.length)
+        : stageSnapshot("episode_plan", runningStage === "episode_plan" ? "running" : "pending", 0, 1);
+    const batchPlanStage = batches.length > 0
+        ? stageSnapshot("batch_plan", "success", batches.length, batches.length)
+        : stageSnapshot("batch_plan", runningStage === "batch_plan" ? "running" : "pending", 0, 1);
+    const titleDeg = isDict(state["title_degraded"]) ? state["title_degraded"] : null;
+    const episodeTitlesStage = stageSnapshot("episode_titles", episodes.length === 0
+        ? runningStage === "episode_titles" ? "running" : "pending"
+        : titleDeg && Number(titleDeg["count"] ?? 0) > 0 ? "warning" : "success", episodes.length > 0 ? episodes.length : 0, episodes.length > 0 ? episodes.length : 1, titleDeg && Number(titleDeg["count"] ?? 0) > 0
+        ? `deterministic titles: ${asList(titleDeg["episodes"]).join(", ")}`
+        : "");
+    const batchStatus = errorBatches > 0
+        ? "error"
+        : doneBatches === batches.length && batches.length > 0
+            ? "success"
+            : runningStage === "batch_extract"
+                ? "running"
+                : "pending";
+    const batchStage = {
+        ...stageSnapshot("batch_extract", batchStatus, doneBatches, batches.length),
+        pending: pendingBatches,
+        error: errorBatches,
+    };
+    const episodeMergeStatus = errorBatches > 0
+        ? "error"
+        : episodeResults === episodes.length && episodes.length > 0
+            ? "success"
+            : runningStage === "episode_merge"
+                ? "running"
+                : "pending";
+    const episodeMergeStage = stageSnapshot("episode_merge", episodeMergeStatus, episodeResults, episodes.length);
+    const synopsisWarning = degradedSynopsisEpisodes.size;
+    const episodeSynopsisStatus = synopsisWarning > 0
+        ? "warning"
+        : episodeSynopses === episodes.length && episodes.length > 0
+            ? "success"
+            : runningStage === "episode_synopsis"
+                ? "running"
+                : "pending";
+    const episodeSynopsisStage = {
+        ...stageSnapshot("episode_synopsis", episodeSynopsisStatus, episodeSynopses, episodes.length),
+        warning: synopsisWarning,
+    };
+    const scriptStage = fileStage("script_merge", path.join(dd, "script.initial.json"), runningStage ?? "");
+    const curationStage = fileStage("asset_curation", path.join(dd, "asset_curation.json"), runningStage ?? "");
+    const metadataStage = fileStage("metadata_extract", path.join(dd, "asset_metadata.json"), runningStage ?? "");
+    const synopsisPath = path.join(dd, "synopsis.json");
+    const summaryLine = formatSummaryStatusLine(Boolean(state["summary_skipped"]), Boolean(state["summary_degraded"]), asList(state["summary_degraded_episodes"]).map((n) => Number(n)));
+    const scriptSynopsisStatus = exists(synopsisPath)
+        ? Boolean(state["summary_degraded"]) ? "warning" : "success"
+        : Boolean(state["summary_skipped"])
+            ? "skipped"
+            : runningStage === "script_synopsis"
+                ? "running"
+                : "pending";
+    const scriptSynopsisStage = stageSnapshot("script_synopsis", scriptSynopsisStatus, exists(synopsisPath) ? 1 : 0, 1, summaryLine ?? "");
+    const validationPath = path.join(dd, "validation.json");
+    let validationStage = fileStage("validate", validationPath, runningStage ?? "");
+    if (exists(validationPath)) {
+        const validation = readJson(validationPath);
+        validationStage = stageSnapshot("validate", Boolean(validation["passed"]) ? "success" : "warning", 1, 1);
+    }
+    const stages = [
+        sourceStage,
+        episodePlanStage,
+        batchPlanStage,
+        episodeTitlesStage,
+        batchStage,
+        episodeMergeStage,
+        episodeSynopsisStage,
+        scriptStage,
+        curationStage,
+        metadataStage,
+        scriptSynopsisStage,
+        validationStage,
+    ].map((stage) => failedStage === stage.name ? { ...stage, status: "error", error: Math.max(1, stage.error) } : stage);
+    let overallStatus = "pending";
+    const maxStage = stages.reduce((max, stage) => statusPriority(stage.status) > statusPriority(max) ? stage.status : max, "success");
+    if (runStatus === "init_failed" || runStatus === "init_incomplete" || maxStage === "error")
+        overallStatus = "error";
+    else if (runStatus === "init_running" || maxStage === "running")
+        overallStatus = "running";
+    else if (maxStage === "warning")
+        overallStatus = "warning";
+    else if (stages.filter((s) => s.name !== "script_synopsis").every((s) => s.status === "success" || s.status === "warning"))
+        overallStatus = "success";
+    return {
+        overall_status: overallStatus,
+        running_stage: runningStage,
+        progress_percent: snapshotProgressPercent(stages),
+        stages,
+        episodes: episodeSnapshots,
+        batches: batchDetails,
+    };
+}
+function renderDirectStatusResult(snapshot) {
+    const completedEpisodes = snapshot.episodes.filter((episode) => episode.status === "success").length;
+    const result = [
+        "Overall",
+        `overall: ${statusText(snapshot.overall_status)}; current: ${snapshot.running_stage && isDirectStageName(snapshot.running_stage) ? stageLabel(snapshot.running_stage) : "-"}; progress: ${snapshot.progress_percent}%`,
+        snapshot.episodes.length > 0 ? `episodes: ${Math.round((completedEpisodes / snapshot.episodes.length) * 100)}% 完成` : "episodes: 等待中",
+        "Stages",
+    ];
+    for (const stage of userStageRows(snapshot.stages)) {
+        result.push(`${stageLabel(stage.name)}: ${statusText(stage.status)} ${stage.percent}%${stage.error ? `, error ${stage.error}` : ""}${stage.warning ? `, warning ${stage.warning}` : ""}${stage.status === "pending" ? ", 等待中" : ""}${stage.message ? ` - ${stage.message}` : ""}`);
+    }
+    result.push("Episodes");
+    for (const episode of snapshot.episodes) {
+        const percent = episode.batches_total > 0 ? Math.round((episode.batches_done / episode.batches_total) * 100) : 0;
+        const errors = episode.error_batches.length > 0 ? `, error ids: ${episode.error_batches.join(",")}` : "";
+        result.push(`${episode.episode_id}: ${statusText(episode.status)} ${percent}%, story ${statusText(episode.synopsis_status)}${errors}`);
+    }
+    result.push("Details");
+    const noisyBatches = snapshot.batches.filter((batch) => batch.status !== "success");
+    if (noisyBatches.length === 0) {
+        result.push("no error/warning/pending details");
+    }
+    else {
+        for (const batch of noisyBatches.slice(0, 50)) {
+            const reason = batch.error_code || batch.error_type || batch.message;
+            result.push(`${batch.batch_id}: ${statusText(batch.status)} ep_${pad3(batch.episode)}${reason ? ` - ${reason}` : ""}`);
+        }
+        if (noisyBatches.length > 50)
+            result.push(`${noisyBatches.length - 50} more non-success details not shown`);
+    }
+    return result;
+}
 // Delete result/meta/error/markdown files whose unit key is no longer in the
 // current plan (e.g. the source shed an episode). Pure function of the plan —
 // it never inspects hashes, content, or run_state, so it can only remove units
@@ -659,6 +1255,19 @@ async function buildScriptSynopsis(provider, script, opts) {
 // command_init
 // ---------------------------------------------------------------------------
 export async function commandInit(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    try {
+        return await commandInitImpl(opts);
+    }
+    catch (exc) {
+        emitFailedInitProgress(workspace);
+        throw exc;
+    }
+    finally {
+        finishInitProgress();
+    }
+}
+async function commandInitImpl(opts) {
     const sourcePathArg = strOf(opts["source_path"]);
     const source = sourcePathArg.startsWith("~")
         ? path.join(process.env.HOME ?? "", sourcePathArg.slice(1))
@@ -731,6 +1340,7 @@ export async function commandInit(opts) {
         concurrency,
         source_path: path.resolve(source),
     });
+    emitInitProgress(workspace, "source_prepare");
     let info;
     try {
         info = await prepareSource(source, workspace);
@@ -762,6 +1372,7 @@ export async function commandInit(opts) {
     const sourceText = readText(sourceTextPath);
     const manifest = makeSourceManifest(source, sourceTextPath, info);
     updateRunState(workspace, { status: "init_running", init_stage: "episode_plan" });
+    emitInitProgress(workspace, "episode_plan");
     let plan;
     try {
         plan = buildEpisodePlan(sourceText);
@@ -776,12 +1387,12 @@ export async function commandInit(opts) {
             nextSteps: ["Inspect workspace/source.txt, fix the source file, and rerun init."],
         });
     }
-    updateRunState(workspace, { status: "init_running", init_stage: "provider" });
+    updateRunState(workspace, { status: "init_running", init_stage: "episode_titles" });
     const capabilities = providerCapabilities(providerName);
     if (capabilities && !capabilities.extractBatch && !capabilities.extractEpisode) {
         throw initFailedReport(workspace, {
             title: "INIT FAILED: provider lacks batch extraction",
-            stage: "provider",
+            stage: "episode_titles",
             required: ["provider.extractBatch or provider.extractEpisode"],
             received: [`--provider ${providerName}`],
             nextSteps: ["Use --provider anthropic or --provider mock for direct init."],
@@ -795,7 +1406,7 @@ export async function commandInit(opts) {
         if (exc instanceof CliError) {
             updateRunState(workspace, {
                 status: "init_failed",
-                init_stage: "provider",
+                init_stage: "episode_titles",
                 last_error: { title: exc.title, received: exc.received, failed_at: checkpointTimestamp() },
             });
         }
@@ -804,13 +1415,14 @@ export async function commandInit(opts) {
     if (!provider.extractBatch && !provider.extractEpisode) {
         throw initFailedReport(workspace, {
             title: "INIT FAILED: provider lacks batch extraction",
-            stage: "provider",
+            stage: "episode_titles",
             required: ["provider.extractBatch or provider.extractEpisode"],
             received: [`--provider ${providerName}`],
             nextSteps: ["Use --provider anthropic or --provider mock for direct init."],
         });
     }
     updateRunState(workspace, { status: "init_running", init_stage: "episode_titles" });
+    emitInitProgress(workspace, "episode_titles");
     const titleDegraded = await enrichEpisodeTitlesChunked(workspace, sourceText, plan, provider, concurrency);
     let batchPlan;
     try {
@@ -834,6 +1446,7 @@ export async function commandInit(opts) {
     writeJson(path.join(dd, "source_manifest.json"), manifest);
     writeJson(path.join(dd, "episode_plan.json"), plan);
     writeJson(path.join(dd, "batch_plan.json"), batchPlan);
+    emitInitProgress(workspace, "batch_plan", "success");
     const episodeResultsDir = path.join(dd, "episode_results");
     const batchResultsDir = path.join(dd, "batch_results");
     fs.mkdirSync(episodeResultsDir, { recursive: true });
@@ -900,6 +1513,7 @@ export async function commandInit(opts) {
         episode_total: totalEpisodes,
         batch_total: totalBatches,
     });
+    emitInitProgress(workspace, "batch_extract");
     // Persist each batch the moment it finishes (inside the worker), NOT after the
     // whole pool drains. Per-unit files have no shared index, so concurrent writes
     // are safe — and batch_results/ fills up live, so a crash/kill mid-run keeps
@@ -911,10 +1525,12 @@ export async function commandInit(opts) {
             const errorPath = batchErrorPath(batchResultsDir, batch);
             if (exists(errorPath))
                 deletePath(errorPath);
+            emitInitProgress(workspace, "batch_extract");
             return true;
         }
         catch (error) {
             writeBatchFailure(batchResultsDir, batch, error);
+            emitInitProgress(workspace, "batch_extract");
             return false;
         }
     });
@@ -927,6 +1543,15 @@ export async function commandInit(opts) {
     // reported; assembling them is left to an explicit re-run.
     const results = [];
     const incompleteEpisodes = [];
+    updateRunState(workspace, {
+        status: "init_running",
+        init_stage: "episode_merge",
+        episode_total: totalEpisodes,
+        batch_total: totalBatches,
+        batch_completed: doneBatches,
+        batch_failed: erroredBatches,
+    });
+    emitInitProgress(workspace, "episode_merge");
     try {
         // Assemble every complete episode (incomplete ones are reported and skipped).
         for (const episode of asList(plan["episodes"])) {
@@ -946,9 +1571,12 @@ export async function commandInit(opts) {
             validateEpisodeExtractionQuality(sourceText, episode, merged);
             results.push(merged); // complete episodes only; carries `episode` for the write below
         }
+        emitInitProgress(workspace, "episode_merge", incompleteEpisodes.length > 0 ? "warning" : "success");
         // Episode-level synopsis (reduce-1): resolve each result's synopsis in place
         // (passthrough / reuse / skip / concurrent LLM stitch). Reads prior `syn`
         // BEFORE the persist loop below overwrites ep_NNN.json.
+        updateRunState(workspace, { status: "init_running", init_stage: "episode_synopsis" });
+        emitInitProgress(workspace, "episode_synopsis");
         summaryDegradedEpisodes.push(...await resolveEpisodeSynopses(provider, results, {
             resultsDir: episodeResultsDir,
             resummarize,
@@ -964,6 +1592,7 @@ export async function commandInit(opts) {
             if (exists(errPath))
                 deletePath(errPath);
         }
+        emitInitProgress(workspace, "episode_synopsis", summaryDegradedEpisodes.length > 0 ? "warning" : "success");
     }
     catch (exc) {
         const e = exc;
@@ -989,12 +1618,13 @@ export async function commandInit(opts) {
             batch_failed: erroredBatches,
             last_error: { title: "INIT INCOMPLETE: Some episodes have unextracted batches", failed_at: checkpointTimestamp() },
         });
+        emitInitProgress(workspace, "batch_extract", "error");
         const report = {
             title: "INIT INCOMPLETE: Some episodes have unextracted batches",
             result: [
                 `episodes: ${results.length}/${totalEpisodes} complete`,
                 `incomplete episodes: ${incompleteEpisodes.join(", ")}`,
-                `batches: ${doneBatches}/${totalBatches} done, ${erroredBatches} error`,
+                `content progress: ${totalBatches > 0 ? Math.round((doneBatches / totalBatches) * 100) : 0}% done, ${erroredBatches} error`,
                 ...(titleDegraded.length > 0 ? [`titles degraded (deterministic): ${titleDegraded.join(", ")}`] : []),
                 `provider: ${providerName}`,
             ],
@@ -1007,16 +1637,16 @@ export async function commandInit(opts) {
                 path.join(dd, "run_state.json"),
             ],
             next: [
-                "Run `direct status` to see per-episode batch state.",
-                "Re-run one episode with `direct init --episodes <n>`, one batch with `--batches <key>`, or all errors with `--retry-errors`.",
-                "Errored batches are left untouched on a plain rerun; select them to retry.",
+                "Run `direct status` to see episode progress.",
+                "Re-run one episode with `direct init --episodes <n>`, or all errors with `--retry-errors`.",
+                "Errored units are left untouched on a plain rerun; select them to retry.",
             ],
         };
         return [report, EXIT_RUNTIME];
     }
     updateRunState(workspace, {
         status: "init_running",
-        init_stage: "episode_merge",
+        init_stage: "script_merge",
         episode_total: totalEpisodes,
         episode_completed: results.length,
         incomplete_episodes: [],
@@ -1027,7 +1657,7 @@ export async function commandInit(opts) {
     });
     let script;
     try {
-        updateRunState(workspace, { status: "init_running", init_stage: "script_merge" });
+        emitInitProgress(workspace, "script_merge");
         script = mergeEpisodeResults(results, strOf(info["projectName"]) || path.basename(source, path.extname(source)));
     }
     catch (exc) {
@@ -1043,6 +1673,7 @@ export async function commandInit(opts) {
     }
     try {
         updateRunState(workspace, { status: "init_running", init_stage: "asset_curation" });
+        emitInitProgress(workspace, "asset_curation");
         // Location merge is deterministic-only: actor/prop pruning runs from scene
         // counts and every location is kept. The previous provider location-merge
         // call was removed (single large streaming request kept dropping the gateway
@@ -1063,8 +1694,10 @@ export async function commandInit(opts) {
             updates: { episode_completed: results.length },
         });
     }
+    emitInitProgress(workspace, "asset_curation", "success");
     try {
         updateRunState(workspace, { status: "init_running", init_stage: "metadata_extract" });
+        emitInitProgress(workspace, "metadata_extract");
         let metadata = provider.extractMetadata ? await provider.extractMetadata(sourceText, script) : {};
         if (!isDict(metadata))
             metadata = {};
@@ -1094,13 +1727,15 @@ export async function commandInit(opts) {
             updates: { episode_completed: results.length },
         });
     }
+    emitInitProgress(workspace, "metadata_extract", "success");
     // Whole-script overview (reduce-2). Soft: a non-essential concept enhancement,
     // the opposite of batch extraction's hard-fail policy — failures degrade the
     // overview (recorded as summary_degraded + a sanitized reason) and NEVER block init.
     let summaryFullDegraded = false;
     let summaryDegradeReason = "";
     try {
-        updateRunState(workspace, { status: "init_running", init_stage: "summary" });
+        updateRunState(workspace, { status: "init_running", init_stage: "script_synopsis" });
+        emitInitProgress(workspace, "script_synopsis");
         const summary = await buildScriptSynopsis(provider, script, {
             dd,
             thresholdChars: summaryThresholdChars,
@@ -1120,7 +1755,15 @@ export async function commandInit(opts) {
     const summaryDegraded = summaryFullDegraded || summaryDegradedEpisodes.length > 0;
     const scriptPath = path.join(dd, "script.initial.json");
     writeJson(scriptPath, script);
+    updateRunState(workspace, {
+        summary_skipped: skipSummary,
+        summary_degraded: summaryDegraded,
+        summary_degraded_episodes: summaryDegradedEpisodes,
+        summary_degraded_reason: summaryDegradeReason || null,
+    });
+    emitInitProgress(workspace, "script_synopsis", summaryDegraded ? "warning" : skipSummary ? "skipped" : "success");
     updateRunState(workspace, { status: "init_running", init_stage: "validate" });
+    emitInitProgress(workspace, "validate");
     let validation;
     try {
         validation = validateScript(workspace, scriptPath);
@@ -1166,6 +1809,7 @@ export async function commandInit(opts) {
         summary_degraded_reason: summaryDegradeReason || null,
         last_error: null,
     });
+    emitInitProgress(workspace, "validate", passed ? "success" : "warning");
     const title = passed
         ? "INIT COMPLETE: Initial script ready"
         : "INIT NEEDS AGENT: Initial script written with repair issues";
@@ -1180,7 +1824,7 @@ export async function commandInit(opts) {
             `validation: ${passed ? "passed" : "needs repair"}`,
             `provider: ${providerName}`,
             `episodes: ${results.length}/${totalEpisodes} complete`,
-            `batches: ${doneBatches}/${totalBatches} done (reused ${reusedBatchCount})`,
+            `content progress: ${totalBatches > 0 ? Math.round((doneBatches / totalBatches) * 100) : 0}% done`,
             ...(titleDegraded.length > 0 ? [`titles degraded (deterministic): ${titleDegraded.join(", ")}`] : []),
             ...(summaryLine ? [summaryLine] : []),
         ],
@@ -1219,7 +1863,8 @@ export function commandStatus(opts) {
     const dd = directDir(workspace);
     const episodePlanPath = path.join(dd, "episode_plan.json");
     const batchPlanPath = path.join(dd, "batch_plan.json");
-    if (!exists(episodePlanPath) || !exists(batchPlanPath)) {
+    const hasTrace = exists(path.join(workspace, "source.txt")) || Object.keys(readRunState(workspace)).length > 0;
+    if (!hasTrace && (!exists(episodePlanPath) || !exists(batchPlanPath))) {
         throw new CliError("STATUS BLOCKED: Plan not found", "Plan not found.", {
             exitCode: EXIT_INPUT,
             required: ["episode_plan.json and batch_plan.json"],
@@ -1227,90 +1872,26 @@ export function commandStatus(opts) {
             nextSteps: ["Run scriptctl direct init first."],
         });
     }
-    const episodes = asList(readJson(episodePlanPath)["episodes"]);
-    const batches = asList(readJson(batchPlanPath)["batches"]);
-    const batchResultsDir = path.join(dd, "batch_results");
-    const byEp = new Map();
-    let doneTotal = 0;
-    let errorTotal = 0;
-    for (const batch of batches) {
-        const epNum = Number(batch["episode"]);
-        if (!byEp.has(epNum))
-            byEp.set(epNum, { total: 0, done: 0, error: 0, pending: 0, errorKeys: [], reasons: new Set() });
-        const st = byEp.get(epNum);
-        st.total++;
-        const state = classifyBatch(batchResultsDir, batch);
-        if (state === "done") {
-            st.done++;
-            doneTotal++;
-            continue;
-        }
-        if (state === "error") {
-            st.error++;
-            errorTotal++;
-            st.errorKeys.push(batchResultKey(batch));
-            try {
-                const err = readJson(batchErrorPath(batchResultsDir, batch));
-                st.reasons.add(strOf(err["error_code"] || err["error_type"] || "Error"));
-            }
-            catch {
-                st.reasons.add("Error");
-            }
-        }
-        else {
-            st.pending++;
-        }
-    }
-    const lines = [];
-    let completeEpisodes = 0;
-    const errorEpisodes = [];
-    for (const ep of episodes) {
-        const epNum = Number(ep["episode"]);
-        const st = byEp.get(epNum) ?? { total: 0, done: 0, error: 0, pending: 0, errorKeys: [], reasons: new Set() };
-        let label;
-        if (st.total > 0 && st.done === st.total) {
-            label = "done";
-            completeEpisodes++;
-        }
-        else if (st.error > 0) {
-            label = `ERROR (${st.done}/${st.total} done, ${st.error} err: ${[...st.reasons].join(",")})  [${st.errorKeys.join(",")}]`;
-            errorEpisodes.push(epNum);
-        }
-        else {
-            label = `pending (${st.done}/${st.total} done)`;
-        }
-        lines.push(`${episodeResultKey(ep)}  ${label}`);
-    }
-    // Surface degraded titles (deterministic fallback) recorded by init — they are
-    // not a failure but the agent should know.
-    const state = readRunState(workspace);
-    const titleDeg = isDict(state["title_degraded"]) ? state["title_degraded"] : null;
-    const result = [
-        `episodes: ${completeEpisodes}/${episodes.length} done`,
-        `batches: ${doneTotal}/${batches.length} done, ${errorTotal} error`,
-        `error episodes: ${errorEpisodes.length === 0 ? "-" : errorEpisodes.join(", ")}`,
-    ];
-    if (titleDeg && Number(titleDeg["count"] ?? 0) > 0) {
-        result.push(`titles degraded (deterministic): ${asList(titleDeg["episodes"]).join(", ")}`);
-    }
-    // Surface synopsis state recorded by init: skipped or degraded summaries mean
-    // the overview / some episode synopses are missing or fell back to joined
-    // beats — an agent gating on status should know it isn't a complete summary.
-    // Same formatter as init's report so the two never word it differently.
-    const summaryLine = formatSummaryStatusLine(Boolean(state["summary_skipped"]), Boolean(state["summary_degraded"]), asList(state["summary_degraded_episodes"]).map((n) => Number(n)));
-    if (summaryLine)
-        result.push(summaryLine);
-    result.push(...lines);
-    const allDone = completeEpisodes === episodes.length;
+    const snapshot = buildDirectStatusSnapshot(workspace);
+    const result = renderDirectStatusResult(snapshot);
+    const blockingStatuses = new Set(["error", "pending", "running"]);
+    const allDone = !snapshot.stages.some((stage) => blockingStatuses.has(stage.status));
+    const firstErrorEpisode = snapshot.episodes.find((episode) => episode.status === "error");
     const report = {
         title: "DIRECT STATUS",
         result,
-        artifacts: [batchResultsDir, path.join(dd, "episode_results"), path.join(dd, "run_state.json")],
-        next: errorEpisodes.length > 0
-            ? [`Re-run an errored episode with: direct init --episodes ${errorEpisodes[0]}  (or --batches <key>, or --retry-errors).`]
+        artifacts: [path.join(dd, "batch_results"), path.join(dd, "episode_results"), path.join(dd, "run_state.json")],
+        overall_status: snapshot.overall_status,
+        running_stage: snapshot.running_stage,
+        progress_percent: snapshot.progress_percent,
+        stages: snapshot.stages,
+        episodes: snapshot.episodes,
+        batches: snapshot.batches,
+        next: firstErrorEpisode
+            ? [`Re-run an errored episode with: direct init --episodes ${firstErrorEpisode.episode}  (or --retry-errors).`]
             : allDone
                 ? ["All episodes complete."]
-                : ["Pending batches remain — re-run: direct init (resume) or --episodes <N>."],
+                : ["Pending work remains — re-run: direct init (resume) or --episodes <N>."],
     };
     // Non-zero when the workspace is not fully extracted, so automation can gate
     // on the exit code instead of scraping stdout.