@remixmate/cli 0.9.27 → 0.9.29

package/dist/diagnostics.d.ts

@@ -0,0 +1,4 @@
+export declare function traceHeaders(): Record<string, string>;
+export declare function cleanDiagnosticText(value: string): string;
+/** Opt-in line framing for hosts; stdout is exclusively the existing skill protocol. */
+export declare function diagnostic(exitCode: number, durationMs: number, error?: unknown): void;

package/dist/diagnostics.js

@@ -0,0 +1,39 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+export function traceHeaders() {
+    const parent = process.env.AB_TRACEPARENT ?? '';
+    const match = /^00-([a-f0-9]{32})-([a-f0-9]{16})-[a-f0-9]{2}$/.exec(parent);
+    const trace = match && !/^0+$/.test(match[1]) && !/^0+$/.test(match[2]) ? match[1] : randomBytes(16).toString('hex');
+    const header = `00-${trace}-${randomBytes(8).toString('hex')}-01`;
+    process.env.AB_TRACEPARENT = header;
+    process.env.AB_OPERATION_ID ||= randomUUID();
+    return { traceparent: header };
+}
+export function cleanDiagnosticText(value) {
+    let text = value.replace(/https?:\/\/[^\s"'<>]+/g, raw => {
+        try {
+            const url = new URL(raw);
+            return url.origin + url.pathname;
+        }
+        catch {
+            return '[url]';
+        }
+    }).replace(/(Bearer\s+|(?:token|secret|password|api[_-]?key)\s*[=:]\s*)[^\s,;}]+/gi, '$1[redacted]');
+    for (const [key, secret] of Object.entries(process.env)) {
+        if (/TOKEN|SECRET|PASSWORD|API_KEY/i.test(key) && secret && secret.length >= 6)
+            text = text.split(secret).join('[redacted]');
+    }
+    return Buffer.from(text).subarray(0, 2048).toString('utf8');
+}
+/** Opt-in line framing for hosts; stdout is exclusively the existing skill protocol. */
+export function diagnostic(exitCode, durationMs, error) {
+    if (process.env.AB_DIAGNOSTICS !== '1')
+        return;
+    traceHeaders();
+    const outcome = exitCode === 0 ? 'success' : exitCode === 130 ? 'cancelled' : [2, 3, 4].includes(exitCode) ? 'rejected' : 'failure';
+    const record = { schema_version: 1, timestamp: new Date().toISOString(), service: 'remixmate-cli', environment: process.env.APP_ENV ?? 'dev',
+        level: outcome === 'failure' ? 'error' : 'info', event: 'cli.execution.completed', message: 'CLI execution completed', outcome,
+        trace_id: process.env.AB_TRACEPARENT?.split('-')[1], operation_id: process.env.AB_OPERATION_ID,
+        duration_ms: durationMs, attributes: { exit_code: exitCode },
+        error: error instanceof Error ? { type: error.name, message: cleanDiagnosticText(error.message), stack: cleanDiagnosticText(error.stack ?? '') } : undefined };
+    process.stderr.write('__diagnostic_v1__ ' + JSON.stringify(record) + '\n');
+}

package/dist/http.js

@@ -18,6 +18,7 @@
  *   3. process.env.MM_BACKEND_API_URL   — ab-agent's convention (back-compat)
  *   4. https://api.remixmate.com/api    — production default (zero-config)
  */
+import { traceHeaders, cleanDiagnosticText } from './diagnostics.js';
 import { recordBilling } from './billing.js';
 import { resolvePrivToken, NOT_AUTHENTICATED_HINT } from './auth/resolve.js';
 import { attemptAutoLogin } from './auth/auto-login.js';
@@ -73,7 +74,7 @@ function buildHeaders(ctx, extra) {
         headers['x-invoke-agent'] = ctx.agentName;
     if (ctx.conversationId)
         headers['x-conversation-id'] = ctx.conversationId;
-    return { ...headers, ...extra };
+    return { ...headers, ...extra, ...traceHeaders() };
 }
 /**
  * POST JSON to ab-api and return the parsed business payload.
@@ -110,16 +111,16 @@ export async function mmPost(ctx, pathOrUrl, body, opts = {}) {
             throw new SkillError(`${NOT_AUTHENTICATED_HINT}\n   （后端返回 HTTP ${resp.status}）`, EXIT.NOT_AUTHENTICATED);
         }
         if (resp.status >= 500) {
-            throw new SkillError(`❌ API request failed (HTTP ${resp.status}): ${text}`, EXIT.BACKEND_UNREACHABLE);
+            throw new SkillError(`❌ API request failed (HTTP ${resp.status}): [response omitted]`, EXIT.BACKEND_UNREACHABLE);
         }
-        throw new SkillError(`❌ API request failed (HTTP ${resp.status}): ${text}`);
+        throw new SkillError(`❌ API request failed (HTTP ${resp.status}): [response omitted]`);
     }
     let parsed;
     try {
         parsed = JSON.parse(text);
     }
     catch {
-        throw new SkillError(`❌ failed to parse response, body is not JSON: ${text.slice(0, 200)}`);
+        throw new SkillError(`❌ failed to parse response, body is not JSON: [response omitted]`);
     }
     // Before the code check: a charged response is always code=0 today, but a
     // partial-failure envelope that still billed must not lose its billing line.
@@ -130,7 +131,7 @@ export async function mmPost(ctx, pathOrUrl, body, opts = {}) {
         if (parsed.code === 401 || parsed.code === 403) {
             throw new SkillError(`${NOT_AUTHENTICATED_HINT}\n   （后端返回 code=${parsed.code}${parsed.msg ? `: ${parsed.msg}` : ''}）`, EXIT.NOT_AUTHENTICATED);
         }
-        throw new SkillError(`❌ API returned a business error: ${parsed.msg ?? 'unknown error'} (code=${parsed.code})`);
+        throw new SkillError(`❌ API returned a business error: ${cleanDiagnosticText(parsed.msg ?? 'unknown error')} (code=${parsed.code})`);
     }
     return parsed.data ?? undefined;
 }

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.9.27",
-  "generatedAt": "2026-09-13T09:11:30.410Z",
+  "version": "0.9.29",
+  "generatedAt": "2026-09-14T08:49:05.207Z",
   "skills": [
     {
       "id": "export-jianying",

package/dist/runner.js

@@ -9,6 +9,7 @@
  *
  * Resolves to the child process's exit code so cli.ts can propagate it.
  */
+import { diagnostic, cleanDiagnosticText, traceHeaders } from './diagnostics.js';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { findSkill, SKILLS_DIR } from './registry.js';
@@ -24,9 +25,14 @@ function tokenFlag(args) {
     return typeof value === 'string' ? value : undefined;
 }
 export async function runSkill(skillName, opts) {
+    const started = performance.now();
+    let exitCode = EXIT.ERROR;
+    let failure;
+    traceHeaders();
     const skill = findSkill(skillName, opts.baseDir ?? SKILLS_DIR);
     if (!skill) {
         process.stderr.write(`❌ skill not found: ${skillName}\n`);
+        diagnostic(EXIT.USAGE, performance.now() - started);
         return EXIT.USAGE;
     }
     try {
@@ -40,24 +46,26 @@ export async function runSkill(skillName, opts) {
             case 'python':
                 // Python children talk to ab-api themselves and print their own billing
                 // footer; nothing was charged through this process.
-                return await runPython(skill, opts.rawArgs, auth);
+                return exitCode = await runPython(skill, opts.rawArgs, auth);
             case 'http':
             case 'builtin':
-                return await runHandler(skill, opts.parsedArgs, auth);
+                return exitCode = await runHandler(skill, opts.parsedArgs, auth);
         }
     }
     catch (err) {
+        failure = err;
         if (err instanceof SkillError) {
-            process.stderr.write(err.message + '\n');
-            return err.exitCode;
+            process.stderr.write(cleanDiagnosticText(err.message) + '\n');
+            return exitCode = err.exitCode;
         }
-        process.stderr.write(`❌ unexpected error: ${err.message}\n`);
+        process.stderr.write(`❌ unexpected error: ${cleanDiagnosticText(err.stack ?? err.message)}\n`);
         return EXIT.ERROR;
     }
     finally {
         // In `finally` because a run can fail *after* a billed step (e.g. the image
         // generated and was charged, then the upload timed out) — spend gets
         // reported either way. No-ops when nothing was charged.
+        diagnostic(exitCode, performance.now() - started, failure);
         emitBillingFooter();
     }
 }
@@ -140,7 +148,7 @@ async function applyTakeContext(skill, opts, auth) {
             `(project ${take.projectId}${take.attempt ? `, attempt ${take.attempt}` : ''})\n`);
     }
     catch (err) {
-        process.stderr.write(`⚠️  无法归属本次产物（内容仍会正常生成，但不会出现在项目里）: ${err.message}\n`);
+        process.stderr.write(`⚠️  无法归属本次产物（内容仍会正常生成，但不会出现在项目里）: ${cleanDiagnosticText(err.message)}\n`);
     }
 }
 async function runPython(skill, rawArgs, auth) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.9.27",
+  "version": "0.9.29",
   "description": "AI media generation skills for Claude Code / Codex — 12 skills covering image, video, voice, digital human, web screenshot, web recording, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",
@@ -25,6 +25,7 @@
     "test:template-pipeline": "PYTHONDONTWRITEBYTECODE=1 node dist/cli.js exec -- python3 scripts/test-template-pipeline.py",
     "test:props-contract": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-props-contract.py",
     "test:narration-speed": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-narration-speed.py",
+    "test:render-resume": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-render-resume.py",
     "test:render-plan": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-render-plan-snapshot.py",
     "test:render-plan:update": "PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-render-plan-snapshot.py --update",
     "test:contracts": "PYTHONDONTWRITEBYTECODE=1 python3 skills/template-registry/scripts/check_contracts.py",

package/skills/render-video/scripts/remote_renderer_client.py

@@ -34,6 +34,9 @@ import urllib.error
 import urllib.parse
 import urllib.request
 from typing import Callable, Optional
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "template-registry" / "scripts"))
+from log_diagnostics import trace_headers
 
 DEFAULT_API_BASE_URL = "https://api-render.remixmate.com"
 API_BASE_URL = (
@@ -61,6 +64,19 @@ class RemoteRenderError(RuntimeError):
     """抛出至调用方，由上层写入 render_plan.errors。"""
 
 
+class RemoteRenderTimeout(RemoteRenderError):
+    """轮询超时 —— 任务**没有失败**，只是我们不等了。
+
+    与普通 RemoteRenderError 分开，是因为上层的处置完全相反：
+    真失败 → 可以重新提交一个任务；超时 → 后端还在渲，重新提交等于白烧一遍，
+    必须保留 taskId 让下一次调用续上。
+    """
+
+    def __init__(self, message: str, task_id: str):
+        super().__init__(message)
+        self.task_id = task_id
+
+
 def _build_headers(private_token: str, content_type: str = "application/json", conversation_id: Optional[str] = None) -> dict:
     if not private_token:
         raise RemoteRenderError("PrivToken is not set (PRIV_TOKEN or --priv-token)")
@@ -74,6 +90,7 @@ def _build_headers(private_token: str, content_type: str = "application/json", c
         headers["x-invoke-agent"] = AGENT_NAME
     if conversation_id:
         headers["x-conversation-id"] = conversation_id
+    headers.update(trace_headers())
     return headers
 
 
@@ -174,9 +191,10 @@ def poll_render(
     while True:
         elapsed = time.monotonic() - start
         if elapsed > timeout:
-            raise RemoteRenderError(
+            raise RemoteRenderTimeout(
                 f"remote render polling timed out (waited {elapsed:.0f}s, taskId={task_id}); "
-                f"the job may still be running on the backend — query {status_path} later"
+                f"the job may still be running on the backend — query {status_path} later",
+                task_id,
             )
 
         try:

package/skills/render-video/scripts/render_video.py

@@ -1647,6 +1647,23 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
         return False
 
 
+def _persist_plan_checkpoint(render_plan: dict, job_id: Optional[int], private_token: str) -> None:
+    """把当前 RenderPlan 存个档（尽力而为，失败只记日志）。
+
+    存在的唯一理由：远端 taskId 必须在**渲染结束之前**就落库。脚本可能在任何时刻
+    被外层超时 SIGTERM，那一刻没有任何机会写盘；只在流程末尾 save_plan 的话，
+    taskId 永远存不下来，"续跑"就无从谈起。
+    """
+    if not job_id:
+        return
+    try:
+        import render_job_client  # type: ignore
+        render_job_client.save_plan(job_id, json.dumps(render_plan, ensure_ascii=False), private_token)
+        LogPrint(f"   💾 RenderPlan checkpoint saved (jobId={job_id})", file=sys.stderr)
+    except Exception as exc:  # noqa: BLE001 — 存档失败不该让渲染本身失败
+        LogPrint(f"   ⚠️  RenderPlan checkpoint failed (jobId={job_id}): {exc}", file=sys.stderr)
+
+
 def render_with_remote_api(
     render_plan: dict,
     output_path: str,
@@ -1656,10 +1673,14 @@ def render_with_remote_api(
     poll_interval: float = 5.0,
     upload_title: Optional[str] = None,
     conversation_id: Optional[str] = None,
+    job_id: Optional[int] = None,
 ) -> bool:
     """Submit render to ab-api /tool/renderVideo and poll until completion.
 
     On success, writes upload.fileUrl into render_plan and skips local MP4 download.
+
+    job_id 用于中途存档（见 _persist_plan_checkpoint）：有它才能在被强杀后续跑，
+    没有则退化成旧行为（一次性，杀了就得重渲）。
     """
     import remote_renderer_client
 
@@ -1706,6 +1727,13 @@ def render_with_remote_api(
     # 内置模板即使带 sourceOssKey（builtin-template-registry 回填，仅服务
     # derive_template 派生），渲染仍走 ab-render 预构建的 /render，绝不走 /renderDraft，
     # 否则会用 OSS 上的旧快照 + DraftMainVideo 复刻渲染，与生产 MainVideo 漂移。
+    # 下面这套 payload 构造在"续跑既有任务"时其实用不上（见后面的 resuming 分支），
+    # 所以它的失败不该让续跑也跟着失败 —— 任务还在后端好好渲着。
+    pending_resume = bool(str(render_plan.get("remoteTaskId") or "").strip())
+    # 先给默认值：presign 失败时下面的分支不会走到，续跑分支仍要读 status_path。
+    render_path = "/render"
+    status_path = "/renderStatus"
+
     source_oss_key = None
     template_id = render_plan.get("templateId", "")
     if template_id:
@@ -1719,20 +1747,27 @@ def render_with_remote_api(
 
     if source_oss_key:
         import render_job_client  # type: ignore
+        tarball_url = None
         try:
             src = render_job_client.presign_template_source(template_id, private_token)
             tarball_url = src.get("tarballUrl")
             if not tarball_url:
                 raise RuntimeError(f"presignSource 未返回 tarballUrl: {src}")
         except Exception as exc:
-            LogPrint(f"❌ presignSource failed for private template {template_id}: {exc}", file=sys.stderr)
-            render_plan["status"] = "failed"
-            render_plan["errors"].append({
-                "phase": "render",
-                "message": f"presignSource failed: {exc}",
-                "timestamp": now_iso(),
-            })
-            return False
+            if pending_resume:
+                LogPrint(
+                    f"⚠️  presignSource failed ({exc}) — 但有待续跑的任务，忽略继续",
+                    file=sys.stderr,
+                )
+            else:
+                LogPrint(f"❌ presignSource failed for private template {template_id}: {exc}", file=sys.stderr)
+                render_plan["status"] = "failed"
+                render_plan["errors"].append({
+                    "phase": "render",
+                    "message": f"presignSource failed: {exc}",
+                    "timestamp": now_iso(),
+                })
+                return False
         payload = {
             "tarballUrl": tarball_url,
             "inputProps": input_props,
@@ -1759,8 +1794,10 @@ def render_with_remote_api(
         status_path = "/renderStatus"
 
     total_frames = config.get("totalFrames", 0)
-    LogPrint(f"🎬 Submitting remote render task...", file=sys.stderr)
-    if source_oss_key:
+    if pending_resume:
+        # 续跑：下面那堆"正在提交"的日志会误导人，跳过
+        LogPrint(f"🎬 Remote render task already exists, will resume polling", file=sys.stderr)
+    elif source_oss_key:
         LogPrint(f"   Private template (OSS dynamic bundle): {template_id}", file=sys.stderr)
     else:
         LogPrint(f"   Composition: {composition_id}", file=sys.stderr)
@@ -1770,28 +1807,54 @@ def render_with_remote_api(
     LogPrint(f"   total frames: {total_frames}", file=sys.stderr)
     sys.stderr.flush()
 
-    try:
-        task_id = remote_renderer_client.start_render(payload, private_token=private_token, conversation_id=conversation_id, path=render_path)
-    except Exception as exc:
-        LogPrint(f"❌ remote render submission failed: {exc}", file=sys.stderr)
-        render_plan["status"] = "failed"
-        render_plan["errors"].append({
+    # ─── 续跑既有任务 ────────────────────────────────────────────────────
+    # 上一次调用可能是被外层超时 SIGTERM 掉的（skill 执行有上限），而远端任务还在
+    # ab-render 上跑着。这时重新提交 = 白烧一遍渲染、并且大概率再次撞上同一个上限。
+    # 所以先看 plan 里有没有上次留下的 taskId：有就直接续着轮询。
+    #
+    # 只在"任务不可用"（已失败 / 查不到）时才退回重新提交 —— 轮询超时不算不可用，
+    # 那条路走 RemoteRenderTimeout，保留 taskId 交给下一次调用。
+    task_id = str(render_plan.get("remoteTaskId") or "").strip()
+    if task_id:
+        # 提交时用的状态端点存在 plan 里（内置模板 /renderStatus，私有模板
+        # /renderDraftStatus）。用存的那个，别依赖这次重新推导的结果。
+        status_path = render_plan.get("remoteStatusPath") or status_path
+        LogPrint(f"🔄 resuming existing remote task: taskId={task_id}", file=sys.stderr)
+        render_plan["logs"].append({
             "phase": "render",
-            "message": f"remote start_render failed: {exc}",
+            "message": f"Resuming remote task: {task_id}",
             "timestamp": now_iso(),
         })
-        return False
+    else:
+        try:
+            task_id = remote_renderer_client.start_render(payload, private_token=private_token, conversation_id=conversation_id, path=render_path)
+        except Exception as exc:
+            LogPrint(f"❌ remote render submission failed: {exc}", file=sys.stderr)
+            render_plan["status"] = "failed"
+            render_plan["errors"].append({
+                "phase": "render",
+                "message": f"remote start_render failed: {exc}",
+                "timestamp": now_iso(),
+            })
+            return False
 
-    LogPrint(f"   ✅ task submitted, taskId={task_id}", file=sys.stderr)
-    render_plan["remoteTaskId"] = task_id
-    render_plan["logs"].append({
-        "phase": "render",
-        "message": f"Remote task submitted: {task_id}",
-        "timestamp": now_iso(),
-    })
+        LogPrint(f"   ✅ task submitted, taskId={task_id}", file=sys.stderr)
+        render_plan["remoteTaskId"] = task_id
+        render_plan["remoteStatusPath"] = status_path
+        render_plan["remoteStartedAt"] = time.time()
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"Remote task submitted: {task_id}",
+            "timestamp": now_iso(),
+        })
+        # **立刻落库**，不等渲染结束。被 SIGTERM 的那一刻脚本没有任何机会写盘，
+        # 所以 taskId 必须在这里就进 DB，否则下一次调用无从续起（这正是旧代码
+        # 只写内存、`remoteTaskId` 全程没人读的后果）。
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
 
     last_progress = -1.0
-    render_start_time = time.time()
+    # 续跑时用提交时刻算 elapsed，否则 ETA 会按"刚开始"估，一上来就偏小。
+    render_start_time = float(render_plan.get("remoteStartedAt") or time.time())
 
     def _on_progress(status_data: dict):
         nonlocal last_progress
@@ -1834,9 +1897,32 @@ def render_with_remote_api(
             adaptive_interval=True,
             status_path=status_path,
         )
+    except remote_renderer_client.RemoteRenderTimeout as exc:
+        # 等不动了，但任务**没失败**。保留 taskId，让下一次调用接着轮询；
+        # 状态不写 failed（写了模型会当成"渲染失败"而重新走一遍完整流程）。
+        LogPrint(f"⏳ {exc}", file=sys.stderr)
+        render_plan["status"] = "rendering"
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
+        render_plan["logs"].append({
+            "phase": "render",
+            "message": f"poll timeout, task still running: {task_id}",
+            "timestamp": now_iso(),
+        })
+        print(
+            f"\n⏳ 远端渲染仍在进行（taskId={task_id}）。"
+            f"用同一个 job_id 再调一次 render_video 即可续上，不会重新渲染。",
+            flush=True,
+        )
+        return False
     except Exception as exc:
         LogPrint(f"❌ remote render polling failed: {exc}", file=sys.stderr)
         render_plan["status"] = "failed"
+        # 任务确实不可用了（失败 / 查不到）。清掉 taskId，否则下一次调用会一直
+        # 去续一个永远好不了的任务，再也提交不了新的。
+        render_plan.pop("remoteTaskId", None)
+        render_plan.pop("remoteStatusPath", None)
+        render_plan.pop("remoteStartedAt", None)
+        _persist_plan_checkpoint(render_plan, job_id, private_token)
         render_plan["errors"].append({
             "phase": "render",
             "message": f"remote poll_render failed: {exc}",
@@ -2030,8 +2116,11 @@ Examples:
     parser.add_argument(
         "--remote-poll-timeout",
         type=float,
-        default=float(os.environ.get("REMOTION_REMOTE_POLL_TIMEOUT", "1800")),
-        help="Remote-render polling timeout (seconds, default 1800)",
+        default=float(os.environ.get("REMOTION_REMOTE_POLL_TIMEOUT", "2700")),
+        # 实测最长的一支约 30 分钟，加上 ab-render 排队要留余量，所以是 45 分钟。
+        # 这个值必须小于 ab-agent 侧 render_video 的 skill 超时（默认 50 分钟），
+        # 否则外层先 SIGTERM，这里这套"超时但保留 taskId"的续跑逻辑根本轮不到执行。
+        help="Remote-render polling timeout (seconds, default 2700)",
     )
     parser.add_argument(
         "--remote-poll-interval",
@@ -2405,6 +2494,7 @@ Examples:
             poll_interval=args.remote_poll_interval,
             upload_title=upload_title_hint,
             conversation_id=conversation_id,
+            job_id=args.job_id if args.save_job else None,
         )
     else:
         LogPrint(f"💻 Using local render mode", file=sys.stderr)

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V20",
+  "version": "V21",
   "skillDescription": "Final-render skill: loads a persisted RenderPlan by `job_id` and drives the Remotion engine to produce the final video.\n\nUse this skill as soon as the user mentions any of these intents (after assets are already prepared):\n- Render the video, composite the video, export the video\n- Turn the prepared assets into the final clip\n- Render with Remotion\n\nPrerequisite: assets must already be generated via `prepare_video_assets`. This skill never resolves or regenerates assets — pass it a `job_id` from a previous `prepare_video_assets` call.\n\n⚠️ Stop-and-confirm gate: never call this skill until the user has explicitly confirmed the assets prepared by `prepare_video_assets`. If those assets were prepared in the current turn and the user has not replied since, stop and ask instead of rendering."
 }

package/skills/template-registry/scripts/log_diagnostics.py

@@ -0,0 +1,32 @@
+"""Portable stdlib-only context and opt-in stderr diagnostics; never writes stdout."""
+import json
+import os
+import re
+import secrets
+import sys
+import time
+import uuid
+from datetime import datetime, timezone
+
+_started = time.monotonic()
+
+def trace_headers():
+    match = re.fullmatch(r'00-([a-f0-9]{32})-([a-f0-9]{16})-[a-f0-9]{2}', os.getenv('AB_TRACEPARENT', ''))
+    tid = match[1] if match and match[1] != '0'*32 and match[2] != '0'*16 else secrets.token_hex(16)
+    parent = f'00-{tid}-{secrets.token_hex(8)}-01'
+    os.environ['AB_TRACEPARENT'] = parent
+    os.environ.setdefault('AB_OPERATION_ID', str(uuid.uuid4()))
+    return {'traceparent': parent}
+
+def diagnostic(exit_code, kind='none', service='remixmate-studio-cli'):
+    if os.getenv('AB_DIAGNOSTICS') != '1':
+        return
+    trace_headers()
+    outcome = 'success' if exit_code == 0 else 'failure' if exit_code == 2 else 'rejected'
+    record = dict(schema_version=1, timestamp=datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z'),
+        level='error' if outcome == 'failure' else 'info', service=service, environment=os.getenv('APP_ENV', 'dev'),
+        event='cli.execution.completed', message='CLI execution completed', outcome=outcome,
+        duration_ms=(time.monotonic()-_started)*1000, trace_id=os.environ['AB_TRACEPARENT'].split('-')[1],
+        operation_id=os.environ['AB_OPERATION_ID'], attributes={'exit_code': exit_code, 'error_kind': kind if re.fullmatch('[a-z_]{1,80}', str(kind)) else 'unknown'})
+    sys.stderr.write('__diagnostic_v1__ ' + json.dumps(record, ensure_ascii=False) + '\n')
+    sys.stderr.flush()

package/skills/template-registry/scripts/render_job_client.py

@@ -11,6 +11,7 @@ gen_jianying_draft.py 使用。
          两个变量语义相同，保留回退是为兼容只配了其中一个的部署环境。
 """
 
+from log_diagnostics import trace_headers
 import json
 import os
 import sys
@@ -34,6 +35,7 @@ def _make_headers(priv_token: str) -> dict:
     agent_name = os.environ.get("AGENT_NAME", "")
     if agent_name:
         headers["x-invoke-agent"] = agent_name
+    headers.update(trace_headers())
     return headers
 
 

package/skills/template-registry/version.json

@@ -2,6 +2,6 @@
   "skillName": "template-registry",
   "repoName": "agent-skill-media-maker",
   "skillId": "475",
-  "version": "V13",
+  "version": "V14",
   "skillDescription": "Video-template registry skill. Stores every video-template definition and lists the available templates (templateId / name / aspect ratio / style tags).\n\nUse this skill as soon as the user mentions any of these intents:\n- View available templates / list every template\n\nNote: DSL→TemplateBinding is no longer a separate exposed step — once prepare_video_assets receives a template_id it builds the binding internally."
 }