chainlesschain 0.47.6 → 0.47.8

package/src/runtime/agent-core.js

@@ -502,6 +502,9 @@ export async function executeTool(name, args, context = {}) {
       externalToolDescriptors: context.externalToolDescriptors || null,
       externalToolExecutors: context.externalToolExecutors || null,
       mcpClient: context.mcpClient || null,
+      shellPolicyOverrides: context.shellPolicyOverrides || null,
+      approvalGate: context.approvalGate || null,
+      shellConfirm: context.shellConfirm || null,
     });
   } catch (err) {
     if (hookDb) {
@@ -569,6 +572,8 @@ async function executeToolInner(
     externalToolExecutors,
     mcpClient,
     shellPolicyOverrides,
+    approvalGate,
+    shellConfirm,
   },
 ) {
   const localToolDescriptor =
@@ -710,19 +715,49 @@ async function executeToolInner(
       const shellPolicyOpts = shellPolicyOverrides
         ? { overrideRuleIds: shellPolicyOverrides }
         : {};
-      const shellPolicy = evaluateShellCommandPolicy(
-        args.command,
-        shellPolicyOpts,
-      );
       const override = getRuntimeToolDescriptorByCommand(args.command);
-      if (!shellPolicy.allowed) {
-        return attachDescriptor(
-          {
-            error: `[Shell Policy] ${shellPolicy.reason}`,
-            shellCommandPolicy: shellPolicy,
-          },
-          override || runtimeDescriptor,
-        );
+      let shellPolicy;
+      let approvalOutcome = null;
+      if (approvalGate) {
+        const { evaluateShellCommandWithApproval } =
+          await import("../lib/shell-approval.js");
+        const gated = await evaluateShellCommandWithApproval({
+          command: args.command,
+          sessionId,
+          approvalGate,
+          shellPolicyOptions: shellPolicyOpts,
+        });
+        shellPolicy = gated.shellPolicy;
+        approvalOutcome = {
+          decision: gated.decision,
+          via: gated.via,
+          riskLevel: gated.riskLevel,
+          policy: gated.policy,
+        };
+        if (!gated.allowed) {
+          return attachDescriptor(
+            {
+              error:
+                gated.via === "shell-policy"
+                  ? `[Shell Policy] ${gated.reason}`
+                  : `[ApprovalGate] command denied (${gated.via})`,
+              shellCommandPolicy: shellPolicy,
+              approval: approvalOutcome,
+            },
+            override || runtimeDescriptor,
+          );
+        }
+      } else {
+        shellPolicy = evaluateShellCommandPolicy(args.command, shellPolicyOpts);
+        if (!shellPolicy.allowed) {
+          return attachDescriptor(
+            {
+              error: `[Shell Policy] ${shellPolicy.reason}`,
+              shellCommandPolicy: shellPolicy,
+            },
+            override || runtimeDescriptor,
+          );
+        }
       }
 
       try {
@@ -736,6 +771,7 @@ async function executeToolInner(
           {
             stdout: output.substring(0, 30000),
             shellCommandPolicy: shellPolicy,
+            approval: approvalOutcome,
           },
           override || runtimeDescriptor,
         );
@@ -746,6 +782,7 @@ async function executeToolInner(
             stderr: (err.stderr || "").substring(0, 2000),
             exitCode: err.status,
             shellCommandPolicy: shellPolicy,
+            approval: approvalOutcome,
           },
           override || runtimeDescriptor,
         );
@@ -1580,7 +1617,14 @@ export async function chatWithTools(rawMessages, options) {
     if (!response.ok) {
       throw new Error(`Ollama error: ${response.status}`);
     }
-    return await response.json();
+    const data = await response.json();
+    if (data.prompt_eval_count || data.eval_count) {
+      data.usage = {
+        input_tokens: data.prompt_eval_count || 0,
+        output_tokens: data.eval_count || 0,
+      };
+    }
+    return data;
   }
 
   if (provider === "anthropic") {
@@ -1627,7 +1671,14 @@ export async function chatWithTools(rawMessages, options) {
     }
 
     const data = await response.json();
-    return _normalizeAnthropicResponse(data);
+    const normalized = _normalizeAnthropicResponse(data);
+    if (data.usage) {
+      normalized.usage = {
+        input_tokens: data.usage.input_tokens || 0,
+        output_tokens: data.usage.output_tokens || 0,
+      };
+    }
+    return normalized;
   }
 
   // OpenAI-compatible providers
@@ -1696,7 +1747,14 @@ export async function chatWithTools(rawMessages, options) {
     throw new Error("Invalid API response: no choices returned");
   }
   const choice = data.choices[0];
-  return { message: choice.message };
+  const out = { message: choice.message };
+  if (data.usage) {
+    out.usage = {
+      input_tokens: data.usage.prompt_tokens || 0,
+      output_tokens: data.usage.completion_tokens || 0,
+    };
+  }
+  return out;
 }
 
 function _normalizeAnthropicResponse(data) {
@@ -1758,6 +1816,8 @@ export async function* agentLoop(messages, options) {
     parentMessages: messages, // pass parent messages for sub-agent auto-condensation
     interaction: options.interaction || null,
     shellPolicyOverrides: options.shellPolicyOverrides || null,
+    approvalGate: options.approvalGate || null,
+    shellConfirm: options.shellConfirm || null,
   };
 
   throwIfAborted(signal);
@@ -1817,6 +1877,17 @@ export async function* agentLoop(messages, options) {
   // real `chatWithTools`.
   const llmCall = options.chatFn || chatWithTools;
 
+  // Phase 5 run bookends — a stable runId lets envelope subscribers correlate
+  // every tool_call / tool_result / message / ended event back to one run.
+  const runId =
+    options.runId ||
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  yield {
+    type: "run-started",
+    runId,
+    sessionId: options.sessionId || null,
+  };
+
   while (budget.hasRemaining()) {
     budget.consume();
     throwIfAborted(signal);
@@ -1877,8 +1948,18 @@ export async function* agentLoop(messages, options) {
     throwIfAborted(signal);
     const msg = result?.message;
 
+    if (result?.usage) {
+      yield {
+        type: "token-usage",
+        provider: options.provider || "ollama",
+        model: options.model || "unknown",
+        usage: result.usage,
+      };
+    }
+
     if (!msg) {
       yield { type: "response-complete", content: "(No response from LLM)" };
+      yield { type: "run-ended", runId, reason: "no-response" };
       return;
     }
 
@@ -1886,6 +1967,7 @@ export async function* agentLoop(messages, options) {
 
     if (!toolCalls || toolCalls.length === 0) {
       yield { type: "response-complete", content: msg.content || "" };
+      yield { type: "run-ended", runId, reason: "complete" };
       return;
     }
 
@@ -1948,6 +2030,7 @@ export async function* agentLoop(messages, options) {
     type: "response-complete",
     content: `(Iteration budget exhausted — ${budget.toSummary()})`,
   };
+  yield { type: "run-ended", runId, reason: "budget-exhausted" };
 }
 
 // ─── Format helpers ───────────────────────────────────────────────────────

package/src/runtime/agent-runtime.js

@@ -199,8 +199,15 @@ export class AgentRuntime {
 
   async startServer() {
     const { logger: runtimeLogger } = this.deps;
-    const { port, maxConnections, timeout, token, allowRemote, project } =
-      this.policy;
+    const {
+      port,
+      maxConnections,
+      timeout,
+      token,
+      allowRemote,
+      project,
+      httpPort,
+    } = this.policy;
     let { host } = this.policy;
 
     if (Number.isNaN(port) || port < 1 || port > 65535) {
@@ -233,15 +240,80 @@ export class AgentRuntime {
       logger: runtimeLogger,
     });
 
+    // Deep Agents Deploy: load agent bundle if --bundle provided.
+    // Bundle's AGENTS.md becomes defaultSystemPromptExtension for all new sessions.
+    // Bundle's MCP servers are connected to the shared mcpClient.
+    let bundleResolved = null;
+    let bundleMcpClient = mcpClient;
+    if (this.policy.bundlePath) {
+      try {
+        const { loadBundle } =
+          await import("@chainlesschain/session-core/agent-bundle-loader");
+        const { resolveBundle } =
+          await import("@chainlesschain/session-core/agent-bundle-resolver");
+        const bundle = loadBundle(this.policy.bundlePath);
+        bundleResolved = resolveBundle(bundle);
+
+        // Connect bundle MCP servers
+        const bundleServers = bundleResolved.mcpConfig?.servers;
+        if (bundleServers && typeof bundleServers === "object") {
+          const entries = Object.entries(bundleServers).filter(
+            ([, cfg]) => cfg && cfg.command,
+          );
+          if (entries.length > 0) {
+            if (!bundleMcpClient) {
+              bundleMcpClient = this.deps.createMcpClient();
+            }
+            for (const [name, cfg] of entries) {
+              try {
+                await bundleMcpClient.connect(name, cfg);
+              } catch (mcpErr) {
+                runtimeLogger.log(
+                  chalk.yellow(
+                    `  Bundle MCP: "${name}" connect failed — ${mcpErr.message}`,
+                  ),
+                );
+              }
+            }
+          }
+        }
+
+        const bid = bundleResolved.manifest?.id || "unknown";
+        runtimeLogger.log(chalk.gray(`  Bundle: loaded ${bid}`));
+      } catch (bundleErr) {
+        runtimeLogger.log(
+          chalk.red(`  Bundle: failed to load — ${bundleErr.message}`),
+        );
+      }
+    }
+
     const sessionManager = this.deps.createSessionManager({
       db,
       defaultProjectRoot: project,
       config: appConfig,
-      mcpClient,
+      mcpClient: bundleMcpClient,
       allowedMcpServerNames: DEFAULT_ALLOWED_MCP_SERVER_NAMES,
       mcpServerRegistry: this.deps.mcpServerRegistry,
+      defaultSystemPromptExtension: bundleResolved?.systemPrompt || null,
     });
 
+    let envelopeBus = null;
+    let httpServer = null;
+    if (httpPort) {
+      if (Number.isNaN(httpPort) || httpPort < 1 || httpPort > 65535) {
+        throw new Error("Invalid --http-port. Must be between 1 and 65535.");
+      }
+      const { createEnvelopeBus, createEnvelopeHttpServer } =
+        await import("../gateways/http/envelope-http-server.js");
+      envelopeBus = createEnvelopeBus();
+      httpServer = createEnvelopeHttpServer({
+        bus: envelopeBus,
+        port: httpPort,
+        host,
+        token,
+      });
+    }
+
     const server = this.deps.createServer({
       port,
       host,
@@ -249,6 +321,7 @@ export class AgentRuntime {
       maxConnections,
       timeout,
       sessionManager,
+      envelopeBus,
     });
 
     server.on("connection", ({ clientId, ip }) => {
@@ -287,10 +360,24 @@ export class AgentRuntime {
       runtimeLogger.log(
         "\n" + chalk.yellow("Shutting down WebSocket server..."),
       );
+      if (
+        bundleMcpClient &&
+        bundleMcpClient !== mcpClient &&
+        typeof bundleMcpClient.disconnectAll === "function"
+      ) {
+        await bundleMcpClient.disconnectAll().catch(() => undefined);
+      }
       if (mcpClient && typeof mcpClient.disconnectAll === "function") {
         await mcpClient.disconnectAll().catch(() => undefined);
       }
       await server.stop();
+      if (httpServer) {
+        try {
+          await httpServer.stop();
+        } catch (_e) {
+          // non-critical
+        }
+      }
       process.exit(0);
     };
 
@@ -299,6 +386,11 @@ export class AgentRuntime {
 
     await server.start();
 
+    let hostedHttp = null;
+    if (httpServer) {
+      hostedHttp = await httpServer.start();
+    }
+
     this.emit(RUNTIME_EVENTS.RUNTIME_START, {
       kind: this.kind,
       policy: { ...this.policy, host },
@@ -313,11 +405,21 @@ export class AgentRuntime {
     runtimeLogger.log(chalk.bold("  ChainlessChain WebSocket Server"));
     runtimeLogger.log("");
     runtimeLogger.log(`  Address:  ${chalk.cyan(`ws://${host}:${port}`)}`);
+    if (hostedHttp) {
+      runtimeLogger.log(
+        `  HTTP SSE: ${chalk.cyan(`http://${hostedHttp.host}:${hostedHttp.port}/v1/sessions/:id/events`)}`,
+      );
+    }
     runtimeLogger.log(
       `  Auth:     ${token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
     );
     runtimeLogger.log(`  Sessions: ${chalk.green("enabled")}`);
     runtimeLogger.log(`  Project:  ${project}`);
+    if (bundleResolved) {
+      runtimeLogger.log(
+        `  Bundle:   ${chalk.green(bundleResolved.manifest?.id || "loaded")}`,
+      );
+    }
     runtimeLogger.log(`  Max conn: ${maxConnections}`);
     runtimeLogger.log(`  Timeout:  ${timeout}ms`);
     runtimeLogger.log("");

package/src/runtime/policies/agent-policy.js

@@ -18,6 +18,14 @@ export function resolveAgentPolicy({
         ? overrides.apiKey
         : llm.apiKey || defaults.apiKey || null,
     sessionId: overrides.sessionId || null,
+    agentId: overrides.agentId || null,
+    recallMemory:
+      overrides.recallMemory === false ? false : overrides.recallMemory,
+    recallLimit: overrides.recallLimit,
+    recallQuery: overrides.recallQuery,
+    noStream: overrides.noStream === true,
+    parkOnExit: overrides.parkOnExit === false ? false : true,
+    bundlePath: overrides.bundlePath || null,
   };
 }
 
@@ -30,6 +38,8 @@ export function resolveServerPolicy(overrides = {}) {
     timeout: overrides.timeout,
     allowRemote: Boolean(overrides.allowRemote),
     project: overrides.project || process.cwd(),
+    httpPort: overrides.httpPort || null,
+    bundlePath: overrides.bundlePath || null,
   };
 }
 

package/src/skills/video-editing/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: video-editing
+description: 长视频素材 + 音乐 → 节奏化蒙太奇剪辑（借鉴 GVCLab/CutClaw）
+version: 0.1.0
+category: media
+source: bundled
+tools:
+  - video_semantic_retrieval
+  - video_shot_trimming
+  - video_review_clip
+  - video_commit_clip
+model-hints:
+  vision: claude-opus-4-6
+  reasoning: claude-opus-4-6
+  asr: openai/whisper-1
+---
+
+## 指南
+
+将长视频素材按音乐节奏剪成短蒙太奇。完整流程分四阶段，由 `pipeline.js` 自动编排：
+
+1. **解构（deconstruct）**: 抽帧 → VLM caption；音频 ASR + 段落分析。结果缓存到 `~/.chainlesschain/video-editing/<sha256>/`
+2. **规划（plan）**: Screenwriter 根据用户指令 + 音乐段落产出 `shot_plan.json`（音乐段 → 镜头骨架）
+3. **组装（assemble）**: Editor ReAct 循环（4 个工具）选时间戳 → `shot_point.json`
+4. **渲染（render）**: ffmpeg 抽片段 + concat + 混音
+
+## 工具
+
+- `video_semantic_retrieval(scene_range)` — 在 scene 索引中拉候选镜头
+- `video_shot_trimming(time_range)` — 帧级断点 + 可用性评估
+- `video_review_clip(start, end)` — 与已选片段做时间区间冲突检测
+- `video_commit_clip(clips[])` — 提交，最多 3 段拼接成一个镜头
+
+## 示例
+
+```bash
+cc video edit \
+  --video resource/raw.mp4 \
+  --audio resource/bgm.mp3 \
+  --instruction "节奏感强的角色蒙太奇"
+```
+
+## 设计参考
+
+- 设计文档: `docs/design/modules/93_CutClaw借鉴_视频剪辑Agent.md`
+- 上游灵感: https://github.com/GVCLab/CutClaw

package/src/skills/video-editing/beat-snap.js

@@ -0,0 +1,127 @@
+/**
+ * beat-snap.js — Snap shot_plan timestamps to nearest beat positions
+ *
+ * CutClaw 对齐逻辑：每个 shot 的 start/end 对齐到最近的 beat，
+ * 保证剪辑点落在节拍上，产生音画同步感。
+ */
+
+export function snapToBeats(shotPlan, beats, options = {}) {
+  const tolerance = options.tolerance ?? 0.5;
+  if (!beats || beats.length === 0) return shotPlan;
+
+  const snapped = {
+    ...shotPlan,
+    sections: (shotPlan.sections || []).map((section) => ({
+      ...section,
+      music_segment: section.music_segment
+        ? snapSegment(section.music_segment, beats, tolerance)
+        : section.music_segment,
+      shots: (section.shots || []).map((shot) =>
+        snapShot(shot, beats, tolerance),
+      ),
+    })),
+  };
+
+  return snapped;
+}
+
+function snapSegment(seg, beats, tolerance) {
+  return {
+    ...seg,
+    start: findNearestBeat(seg.start, beats, tolerance),
+    end: findNearestBeat(seg.end, beats, tolerance),
+  };
+}
+
+function snapShot(shot, beats, tolerance) {
+  if (shot.target_duration == null) return shot;
+  const snappedDuration = snapDurationToBeats(
+    shot.target_duration,
+    beats,
+    tolerance,
+  );
+  return { ...shot, target_duration: snappedDuration };
+}
+
+export function findNearestBeat(time, beats, tolerance = 0.5) {
+  if (!beats || beats.length === 0) return time;
+
+  let best = beats[0];
+  let bestDist = Math.abs(time - beats[0]);
+
+  for (let i = 1; i < beats.length; i++) {
+    const dist = Math.abs(time - beats[i]);
+    if (dist < bestDist) {
+      best = beats[i];
+      bestDist = dist;
+    }
+    if (beats[i] > time + tolerance) break;
+  }
+
+  return bestDist <= tolerance ? best : time;
+}
+
+export function snapDurationToBeats(duration, beats, tolerance = 0.5) {
+  if (!beats || beats.length < 2) return duration;
+
+  const avgInterval = (beats[beats.length - 1] - beats[0]) / (beats.length - 1);
+  if (avgInterval <= 0) return duration;
+
+  const beatCount = Math.round(duration / avgInterval);
+  const snapped = beatCount * avgInterval;
+
+  return Math.abs(snapped - duration) <= tolerance
+    ? parseFloat(snapped.toFixed(3))
+    : duration;
+}
+
+export function buildBeatGrid(beats, downbeats) {
+  if (!beats || beats.length === 0) return { bars: [], beatsPerBar: 4 };
+
+  const dbSet = new Set((downbeats || []).map((d) => d.toString()));
+  let beatsPerBar = 4;
+  if (downbeats && downbeats.length >= 2) {
+    const dbIntervals = [];
+    for (let i = 1; i < downbeats.length; i++) {
+      const count = beats.filter(
+        (b) => b >= downbeats[i - 1] && b < downbeats[i],
+      ).length;
+      if (count > 0) dbIntervals.push(count);
+    }
+    if (dbIntervals.length > 0) {
+      beatsPerBar = median(dbIntervals);
+    }
+  }
+
+  const bars = [];
+  let barStart = 0;
+  let barBeats = [];
+
+  for (const b of beats) {
+    if (dbSet.has(b.toString()) && barBeats.length > 0) {
+      bars.push({ start: barStart, end: b, beats: barBeats });
+      barStart = b;
+      barBeats = [b];
+    } else {
+      if (barBeats.length === 0) barStart = b;
+      barBeats.push(b);
+    }
+  }
+  if (barBeats.length > 0) {
+    bars.push({
+      start: barStart,
+      end: barBeats[barBeats.length - 1],
+      beats: barBeats,
+    });
+  }
+
+  return { bars, beatsPerBar };
+}
+
+function median(arr) {
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0
+    ? Math.round((sorted[mid - 1] + sorted[mid]) / 2)
+    : sorted[mid];
+}