@metagptx/deepflow-suite-cli 0.2.11-dev.20261020.1 → 0.3.1

package/src/cli-install.mjs

@@ -1,140 +1,50 @@
-import { spawn } from "node:child_process";
-import { access, lstat, mkdir, mkdtemp, readlink, rename, rm, symlink, unlink } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import { access, lstat, mkdir, mkdtemp, readFile, realpath, rename, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 
-function run(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd: options.cwd, stdio: "inherit", env: options.env });
-    child.once("error", reject);
-    child.once("exit", (code, signal) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${command} ${args.join(" ")} exited with ${code ?? signal}`));
-    });
-  });
-}
-
-async function replaceLink(source, target) {
-  await mkdir(path.dirname(target), { recursive: true });
+const destinationFor = (binDir) => binDir ? path.resolve(binDir) : path.join(os.homedir(), '.local', 'bin');
+async function inspect(target) { try { return await lstat(target); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } }
+async function matches(target, source) {
   try {
-    const stats = await lstat(target);
-    if (!stats.isSymbolicLink()) {
-      throw new Error(`refusing to replace non-symlink CLI target: ${target}`);
-    }
-    const current = path.resolve(path.dirname(target), await readlink(target));
-    if (current === source) return "unchanged";
-    await unlink(target);
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  await symlink(path.relative(path.dirname(target), source), target);
-  return "created";
+    if (process.platform === 'win32') return (await readFile(target, 'utf8')).includes(source);
+    return await realpath(target) === await realpath(source);
+  } catch { return false; }
 }
-
-async function sourceExists(source) {
-  try {
+export async function installWorkspaceClis({ workspaceRoot, manifest, binDir, force = false }) {
+  const destination = destinationFor(binDir), unchanged = [], targets = [];
+  for (const cli of manifest.clis) {
+    const source = path.resolve(workspaceRoot, cli.project, cli.entry);
     await access(source);
-    return true;
-  } catch {
-    return false;
+    const target = path.join(destination, cli.name + (process.platform === 'win32' ? '.cmd' : ''));
+    if (await matches(target, source)) { unchanged.push(cli.name); continue; }
+    const stats = await inspect(target);
+    if (stats?.isDirectory() || (stats && !force)) throw Error(`refusing to replace existing CLI without --force: ${target}`);
+    targets.push({ name: cli.name, source, target });
   }
-}
-
-export async function installWorkspaceClis({ workspaceRoot, manifest, binDir, force = false }) {
-  const destination = binDir
-    ? path.resolve(binDir)
-    : path.join(process.env.HOME ?? os.homedir(), ".local", "bin");
-  const result = { linked: [], built: [] };
-
   await mkdir(destination, { recursive: true });
-  const targets = manifest.clis.map((cli) => ({ cli, target: path.join(destination, cli.name) }));
-  for (const { cli, target } of targets) {
-    try {
-      const stats = await lstat(target);
-      if (!force) {
-        throw new Error(`refusing to replace existing CLI without --force: ${target}`);
-      }
-      if (stats.isDirectory()) throw new Error(`refusing to replace CLI directory: ${target}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-
-  const backup = await mkdtemp(path.join(destination, ".deepflow-cli-backup-"));
-  const backedUp = [];
-  const touched = [];
+  const backup = await mkdtemp(path.join(destination, '.deepflow-cli-backup-'));
+  const backedUp = [], installed = [];
   try {
-    for (const { cli, target } of targets) {
-      try {
-        await lstat(target);
-        await rename(target, path.join(backup, cli.name));
-        backedUp.push(cli.name);
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-    }
-
-  for (const cli of manifest.clis) {
-    const projectRoot = path.join(workspaceRoot, cli.project);
-    const target = path.join(destination, cli.name);
-
-    if (cli.name === "df-workbench") {
-      const source = path.join(projectRoot, "cli", "df-workbench.mjs");
-      if (!(await sourceExists(source))) throw new Error(`missing CLI source: ${source}`);
-      await replaceLink(source, target);
-      touched.push(cli.name);
-      result.linked.push(cli.name);
-      continue;
-    }
-
-    if (cli.name === "df-agentrt") {
-      await run("make", ["build"], { cwd: projectRoot, env: process.env });
-      const source = path.join(projectRoot, "deploy", "bin", "df-agentrt");
-      if (!(await sourceExists(source))) throw new Error(`missing built CLI: ${source}`);
-      await replaceLink(source, target);
-      touched.push(cli.name);
-      result.built.push(cli.name);
-      continue;
+    for (const entry of targets) {
+      if (await inspect(entry.target)) { await rename(entry.target, path.join(backup, entry.name)); backedUp.push(entry); }
+      if (process.platform === 'win32') await writeFile(entry.target, `@ECHO off\r\n"${process.execPath}" "${entry.source}" %*\r\n`);
+      else await symlink(path.relative(destination, entry.source), entry.target);
+      installed.push(entry);
     }
-
-    await run("make", ["install-cli", `BIN_DIR=${destination}`], {
-      cwd: projectRoot,
-      env: process.env,
-    });
-    touched.push(cli.name);
-    result.built.push(cli.name);
-  }
-
-  await rm(backup, { recursive: true, force: true });
-  return { binDir: destination, ...result };
+    return { binDir: destination, linked: installed.map((entry) => entry.name), unchanged };
   } catch (error) {
-    for (const { cli } of targets) await rm(path.join(destination, cli.name), { recursive: true, force: true });
-    for (const name of backedUp) await rename(path.join(backup, name), path.join(destination, name));
+    for (const entry of installed) await rm(entry.target, { force: true });
+    for (const entry of backedUp) await rename(path.join(backup, entry.name), entry.target);
     throw error;
-  } finally {
-    await rm(backup, { recursive: true, force: true });
-  }
+  } finally { await rm(backup, { recursive: true, force: true }); }
 }
-
 export async function verifyWorkspaceClis({ workspaceRoot, manifest, binDir }) {
-  const destination = binDir
-    ? path.resolve(binDir)
-    : path.join(process.env.HOME ?? os.homedir(), ".local", "bin");
-  const missing = [];
-  const invalid = [];
+  const bin = destinationFor(binDir), missing = [], invalid = [];
   for (const cli of manifest.clis) {
-    try {
-      const target = path.join(destination, cli.name);
-      const stats = await lstat(target);
-      await access(target);
-      if (stats.isDirectory()) invalid.push({ name: cli.name, reason: "target is a directory" });
-    } catch (error) {
-      if (error.code === "ENOENT") {
-      missing.push(cli.name);
-      } else {
-        invalid.push({ name: cli.name, reason: error.message });
-      }
-    }
+    const target = path.join(bin, cli.name + (process.platform === 'win32' ? '.cmd' : ''));
+    const source = path.resolve(workspaceRoot, cli.project, cli.entry);
+    if (!await inspect(target)) missing.push(cli.name);
+    else if (!await matches(target, source)) invalid.push({ name: cli.name, reason: 'CLI points to another installation', expected: source, actual: target });
   }
-  return { binDir: destination, missing, invalid };
+  return { binDir: bin, missing, invalid };
 }

package/src/commands/doctor.mjs

@@ -25,6 +25,8 @@ export async function doctor(options) {
       const clis = await verifyPackageClis({
         packageRoot: path.dirname(options.manifestPath),
         expectedVersion: manifest.version,
+        checkPath: true,
+        env: options.env ?? process.env,
       });
       return {
         ok: clis.ok,

package/src/linker.mjs

@@ -24,7 +24,7 @@ async function inspectTarget(targetPath) {
 
 export async function installWorkspaceSkills({ workspaceRoot, targetDir, force = false, manifestPath }) {
   const manifest = await loadManifest(manifestPath);
-  const skills = resolveSkillSources(manifest, workspaceRoot, "workspace");
+  const skills = resolveSkillSources(manifest, workspaceRoot);
   const destination = targetDir ?? path.join(workspaceRoot, ".agents", "skills");
 
   for (const skill of skills) {
@@ -68,7 +68,7 @@ export async function installWorkspaceSkills({ workspaceRoot, targetDir, force =
 
 export async function verifyWorkspaceSkills({ workspaceRoot, targetDir, manifestPath }) {
   const manifest = await loadManifest(manifestPath);
-  const skills = resolveSkillSources(manifest, workspaceRoot, "workspace");
+  const skills = resolveSkillSources(manifest, workspaceRoot);
   const destination = targetDir ?? path.join(workspaceRoot, ".agents", "skills");
   const missing = [];
   const invalid = [];

package/src/manifest.mjs

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { CLI_NAMES, DISTRIBUTION, PACKAGE_NAME, SKILL_NAMES } from "./constants.mjs";
+import { CLI_NAMES, DISTRIBUTION, SKILL_NAMES } from "./constants.mjs";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -10,6 +10,7 @@ export const defaultManifestPath = path.join(packageRoot, "manifest.json");
 
 export async function loadManifest(manifestPath = defaultManifestPath) {
   const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  if (!manifest.version) manifest.version = JSON.parse(await readFile(path.join(path.dirname(manifestPath), 'package.json'), 'utf8')).version;
   validateManifest(manifest);
   return manifest;
 }
@@ -50,23 +51,16 @@ export function validateManifest(manifest) {
     }
   }
   for (const cli of manifest.clis) {
-    if (!cli || typeof cli.name !== "string" || typeof cli.project !== "string" || typeof cli.install !== "string") {
-      throw new Error("DeepFlow manifest CLIs must define name, project, and install");
+    if (!cli || typeof cli.name !== "string" || typeof cli.project !== "string" || typeof cli.entry !== "string") {
+      throw new Error("DeepFlow manifest CLIs must define name, project, and entry");
     }
+    if (path.isAbsolute(cli.entry) || cli.entry.split(/[\\/]/).includes('..') || !cli.entry.endsWith('.mjs')) throw new Error(`invalid Node CLI entry: ${cli.name}`);
   }
 }
 
-export function resolveSkillSources(manifest, workspaceRoot, mode = "workspace") {
+export function resolveSkillSources(manifest, workspaceRoot) {
   return manifest.skills.map((skill) => ({
     ...skill,
-    sourcePath: path.resolve(workspaceRoot, mode === "package" ? (skill.packageSource || `skills/${skill.name}`) : skill.source),
+    sourcePath: path.resolve(workspaceRoot, skill.source),
   }));
 }
-
-export function packageManifest() {
-  return {
-    distribution: DISTRIBUTION,
-    package: PACKAGE_NAME,
-    cli: "deepflow-suite",
-  };
-}

package/src/package-cli.mjs

@@ -1,66 +1,50 @@
-import { access, lstat } from "node:fs/promises";
-import path from "node:path";
-
-import { resolveInstalledPackageRoot } from "./cli-launcher.mjs";
-import { verifyRuntimePackage } from "./runtime-build.mjs";
-import { runtimeBinaryNames, runtimePackageForPlatform } from "./runtime-package.mjs";
-
-const PACKAGE_BINARIES = ["deepflow-suite", "df-workbench", ...runtimeBinaryNames()];
-
-async function regularFile(filePath) {
-  try {
-    const stats = await lstat(filePath);
-    if (!stats.isFile()) return false;
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
+import { access, readFile, realpath } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { CLI_NAMES } from './constants.mjs';
+
+export const PACKAGE_BINARIES = ['deepflow-suite', ...CLI_NAMES];
+const execute = promisify(execFile);
+export async function commandOnPath(name, env = process.env) {
+  const extensions = process.platform === 'win32' ? ['', '.cmd', '.exe', '.bat'] : [''];
+  for (const dir of (env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    for (const extension of extensions) {
+      const candidate = path.join(dir, name + extension);
+      try { await access(candidate, process.platform === 'win32' ? constants.F_OK : constants.X_OK); return candidate; } catch {}
+    }
   }
 }
-
-export async function verifyPackageClis({
-  packageRoot,
-  expectedVersion,
-  platform = process.platform,
-  arch = process.arch,
-}) {
-  const missing = [];
-  const invalid = [];
-  const binaries = [];
+export async function verifyPackageClis({ packageRoot, expectedVersion, checkPath = false, env = process.env }) {
+  const packageJson = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+  const missing = [], invalid = [], binaries = [];
   for (const name of PACKAGE_BINARIES) {
-    const filePath = path.join(packageRoot, "bin", `${name}.js`);
-    if (await regularFile(filePath)) binaries.push({ name, path: filePath });
-    else missing.push(name);
-  }
-
-  const packageName = runtimePackageForPlatform(platform, arch);
-  const platformInfo = { platform, arch, package: packageName };
-  if (!packageName) {
-    invalid.push({ name: "platform", reason: `unsupported DeepFlow CLI platform: ${platform}/${arch}` });
-  } else {
+    const relative = packageJson.bin?.[name];
+    const entry = relative && path.resolve(packageRoot, relative);
+    if (!entry || !entry.startsWith(path.resolve(packageRoot) + path.sep)) { missing.push(name); continue; }
     try {
-      const runtimeRoot = resolveInstalledPackageRoot(packageRoot, packageName);
-      await verifyRuntimePackage({
-        packageRoot: runtimeRoot,
-        target: platformInfo,
-        expectedVersion,
-      });
-    } catch (error) {
-      invalid.push({ name: packageName, reason: error.message });
-    }
+      await access(entry);
+      const { stdout } = await execute(process.execPath, [entry, '--cli-version', '--json'], { env, timeout: 10000 });
+      const version = JSON.parse(stdout);
+      if (version.name !== name || version.version !== expectedVersion) throw Error(`CLI version ${version.version} does not match ${expectedVersion}`);
+      await execute(process.execPath, [entry, '--help'], { env, timeout: 10000 });
+      const binary = { name, path: entry, version: version.version };
+      if (checkPath) {
+        binary.resolvedPath = await commandOnPath(name, env);
+        if (!binary.resolvedPath) missing.push(name);
+        else {
+          const canonical = await realpath(binary.resolvedPath);
+          const matches = process.platform === 'win32' && /\.(cmd|bat)$/i.test(canonical)
+            ? (await readFile(canonical, 'utf8')).replaceAll('\\', '/').includes(relative.replaceAll('\\', '/'))
+              && [path.resolve(path.dirname(canonical), 'node_modules', packageJson.name), path.resolve(path.dirname(canonical), '..', packageJson.name)].includes(await realpath(packageRoot))
+            : canonical === await realpath(entry);
+          if (!matches) invalid.push({ name, reason: 'another installation shadows this Suite on PATH', expected: entry, actual: binary.resolvedPath });
+        }
+      }
+      binaries.push(binary);
+    } catch (error) { invalid.push({ name, reason: error.message }); }
   }
-
-  const workbenchEntry = path.join(packageRoot, "runtime", "df-workbench.mjs");
-  if (!await regularFile(workbenchEntry)) invalid.push({ name: "df-workbench", reason: "packaged Workbench CLI entry is missing" });
-
-  return {
-    ok: missing.length === 0 && invalid.length === 0,
-    platform: platformInfo,
-    package: packageRoot,
-    binaries,
-    missing,
-    invalid,
-  };
+  return { ok: !missing.length && !invalid.length, package: packageRoot, version: expectedVersion, binaries, missing, invalid };
 }
-
-export { PACKAGE_BINARIES };

package/bin/df-agentctrl.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-import { runRuntimeCli } from "../src/cli-launcher.mjs";
-
-try {
-  process.exitCode = await runRuntimeCli("df-agentctrl", process.argv.slice(2));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bin/df-agentrt.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-import { runRuntimeCli } from "../src/cli-launcher.mjs";
-
-try {
-  process.exitCode = await runRuntimeCli("df-agentrt", process.argv.slice(2));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bin/df-task.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-import { runRuntimeCli } from "../src/cli-launcher.mjs";
-
-try {
-  process.exitCode = await runRuntimeCli("df-task", process.argv.slice(2));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bin/df-taskdriver.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-import { runRuntimeCli } from "../src/cli-launcher.mjs";
-
-try {
-  process.exitCode = await runRuntimeCli("df-taskdriver", process.argv.slice(2));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bin/df-workbench.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-import { runWorkbench } from "../src/cli-launcher.mjs";
-
-try {
-  process.exitCode = await runWorkbench(process.argv.slice(2));
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bundle/skills/deepflow-suite/manifest.yaml

@@ -1,20 +0,0 @@
-id: deepflow-suite
-version: 0.2.9
-kind: composite-skill
-requires:
-  skills:
-    - df-workbench
-    - df-task
-    - df-taskdriver
-    - df-agentctrl
-    - df-agentrt
-    - df-agentrt-repo
-  cli:
-    - df-workbench
-    - df-task
-    - df-taskdriver
-    - df-agentctrl
-    - df-agentrt
-resolution:
-  managed_by: deepflow-suite
-  install_missing_dependencies: false

package/bundle/skills/df-task/skill_test.go

@@ -1,201 +0,0 @@
-package skill
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/deepflow/deepflow-task/internal/authz"
-	"github.com/deepflow/deepflow-task/internal/model"
-	"github.com/deepflow/deepflow-task/internal/validate"
-)
-
-func readFile(t *testing.T, path string) string {
-	t.Helper()
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return string(data)
-}
-
-func TestSkillHasFrontmatter(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	if !strings.HasPrefix(content, "---\n") {
-		t.Fatal("SKILL.md must start with YAML frontmatter")
-	}
-	frontmatter, _, found := strings.Cut(strings.TrimPrefix(content, "---\n"), "\n---")
-	if !found {
-		t.Fatal("frontmatter is not closed")
-	}
-	for _, key := range []string{"name:", "description:"} {
-		if !strings.Contains(frontmatter, key) {
-			t.Errorf("frontmatter is missing %s", key)
-		}
-	}
-	if !strings.Contains(frontmatter, "name: df-task") {
-		t.Errorf("frontmatter name must be df-task, got %q", frontmatter)
-	}
-}
-
-func TestSkillReferenceDocumentsEveryFactType(t *testing.T) {
-	// **十六种全要，不是只要智能体写得了的那九种。** 这份 reference 的作用是让智能体
-	// 读日志时认得每一条事实 —— 只遍历两个 Run 身份的可写集合，把「## 外部输入」
-	// 或「## 推进器写的」整张表删掉照样全绿，而 `external_result` 与 `invocation_ended`
-	// 是三条触发事实里的两条，认不出它们，读日志就读漏了最关键的两种。
-	reference := readFile(t, filepath.Join("references", "fact-types.md"))
-	for _, factType := range model.FactTypes() {
-		if !strings.Contains(reference, string(factType)) {
-			t.Errorf("references/fact-types.md 没有记 %s", factType)
-		}
-	}
-	// 「一共十六种」这个数字也要钉住。不钉的话，将来加第十六种类型时 Task 10 的
-	// `len(payloadSchemas) != len(model.FactTypes())` 会红，而这份文档会悄悄过期。
-	// **两个条件要各给自己的报错。** 合成一句 `if A || B` 的话，「有人把文档里那句话
-	// 删了而类型数还是 15」这一路会红出「文档写的是十六种，而 FactTypes() 有 15 种」
-	// —— 一句不含任何矛盾的话，看的人不知道该改文档还是改代码。而这一路恰好是最
-	// 常见的那一路：改文档比加第十六种类型常见得多。
-	if len(model.FactTypes()) != 16 {
-		t.Errorf("model.FactTypes() 有 %d 种，而 fact-types.md 与本断言都按十六种写的 —— 加了新类型要同时改这两处", len(model.FactTypes()))
-	}
-	if !strings.Contains(reference, "一共十六种事实") {
-		t.Error("fact-types.md 里找不到「一共十六种事实」这句 —— 这个数字是文档过期的唯一机械信号，不要删")
-	}
-}
-
-func TestSkillCommandTablesMatchTheAuthorizationMatrix(t *testing.T) {
-	// 两个方向都要验。只验「不该出现的没出现」，那么往调度一节里插一行
-	// `--type run_outcome` 照样全绿，而任务 Run 读到它就会去写，然后拿一个 403；
-	// 只验「该出现的出现了」，那么删掉一整行命令也照样全绿，而 Agent 在 Run 里
-	// 只有这份文档可读 —— 少一行，那条事实它就永远不会写。
-	content := readFile(t, "SKILL.md")
-	sections := map[model.ActorKind]string{
-		model.ActorTaskRun:      "## 任务 Run 可以写什么",
-		model.ActorSchedulerRun: "## 调度 Run 可以写什么",
-	}
-	for kind, heading := range sections {
-		// strings.Cut 返回三个值：before、after、found。这里要的是标题**之后**那段，
-		// 所以第一个返回值丢掉 —— 接成两个变量编译就过不去。
-		_, afterHeading, found := strings.Cut(content, heading)
-		if !found {
-			t.Fatalf("SKILL.md is missing the %q section", heading)
-		}
-		// 截到下一个 `## ` 为止。两节各自只谈自己那个身份，所以「职责边界」一节里
-		// 那句「写一条 summary 或 help_requested 说明情况」不会被算进调度一节。
-		section, _, _ := strings.Cut(afterHeading, "\n## ")
-		for _, factType := range model.FactTypes() {
-			// 正向只认表格那一列的形状 `| ` + 类型名 + `` ` ``。用裸的 Contains 会被
-			// 同一节的正文喂饱 —— 「`run_outcome` 只是你的主张」「读日志时你看到的是
-			// `dispatch_intent`」这些句子里都有类型名，于是删掉对应那行命令照样全绿，
-			// 而 Agent 在 Run 里只有这份文档可读，少一行那条事实它就永远不会写。
-			inTable := strings.Contains(section, "| `"+string(factType)+"`")
-			// 反向要宽：正文里出现一个写不了的类型，同样会把 Agent 带去拿 403。
-			mentioned := strings.Contains(section, string(factType))
-			switch {
-			case authz.CanWrite(kind, factType) && !inTable:
-				t.Errorf("%s 的命令表里没有 %s，而这个身份写得了它", heading, factType)
-			case !authz.CanWrite(kind, factType) && mentioned:
-				t.Errorf("%s 一节提了 %s，而这个身份写它会拿 403", heading, factType)
-			}
-		}
-	}
-	// 上面那两节里没有推进器的身份，所以唤起生命周期靠这一条兜：整份文档里都不许
-	// 出现「让 Agent 用 append 写它」的样子。
-	for _, factType := range authz.WritableBy(model.ActorDriver) {
-		if strings.Contains(content, string(factType)+" --file") {
-			t.Errorf("SKILL.md shows an agent writing %s; only the driver writes the invocation lifecycle", factType)
-		}
-	}
-}
-
-func TestSkillStatesTheEnvironmentContract(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	// DF_TASK_ID 和 DF_RUN_ID 也在这份清单里：SKILL.md 的示例命令用了它们，
-	// 而它们由 runtime 注入、不由本服务定义。示例里出现却没说明来源，
-	// Agent 就会以为要自己编一个。
-	for _, needle := range []string{"DF_TASK_BASE_URL", "DF_TASK_ACTOR_KIND", "DF_TASK_ACTOR_ID", "DF_TASK_ID", "DF_RUN_ID", "--json"} {
-		if !strings.Contains(content, needle) {
-			t.Errorf("SKILL.md does not mention %s", needle)
-		}
-	}
-}
-
-// 推进器拉起的 Run 里没有人可问。环境门禁若在 Run 内也要求询问，调度 Agent
-// 每一轮都会停下不读事实，而推进器照常记下执行结束——多轮执行就此静默断掉。
-func TestSkillResolvesTheRunEnvironmentWithoutAsking(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	for _, needle := range []string{"### Run 内的目标环境", "`DF_TASK_BASE_URL` 由部署注入", "不根据同名 Service DNS 猜成 dev", "不询问"} {
-		if !strings.Contains(content, needle) {
-			t.Errorf("SKILL.md does not state %q", needle)
-		}
-	}
-}
-
-func TestSkillStatesFactsAreAppendOnly(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	if !strings.Contains(content, "只追加") {
-		t.Fatal("SKILL.md must state that facts are append-only")
-	}
-}
-
-func TestPayloadExamplesPassServerValidation(t *testing.T) {
-	entries, err := os.ReadDir(filepath.Join("assets", "payload-examples"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(entries) == 0 {
-		t.Fatal("there must be at least one payload example")
-	}
-	checked := 0
-	for _, entry := range entries {
-		// 只看 .json。这台机器上到处都是 .DS_Store，不过滤的话它会被当成
-		// 一个叫 ".DS_Store" 的事实类型，测试在一个与代码无关的原因上变红。
-		if !strings.HasSuffix(entry.Name(), ".json") {
-			continue
-		}
-		checked++
-		name := strings.TrimSuffix(entry.Name(), ".json")
-		factType := model.FactType(name)
-		if !model.KnownFactType(factType) {
-			t.Errorf("%s is not a fact type", entry.Name())
-			continue
-		}
-		raw := readFile(t, filepath.Join("assets", "payload-examples", entry.Name()))
-		if !json.Valid([]byte(raw)) {
-			t.Errorf("%s is not valid JSON", entry.Name())
-			continue
-		}
-		if err := validate.Payload(factType, []byte(raw)); err != nil {
-			t.Errorf("%s would be rejected by the server: %v", entry.Name(), err)
-		}
-	}
-	if checked == 0 {
-		t.Fatal("the directory has entries but none of them is a .json example")
-	}
-}
-
-func TestEveryHandWrittenPayloadHasAnExample(t *testing.T) {
-	// 凡是 SKILL.md 让智能体自己写 payload 的事实类型，都要有一份能抄的样例。
-	// 语法糖那三种（dispatch / wait / handoff）的字段由 CLI 填，不需要样例。
-	// **这里两个身份都要走。** 只走任务 Run 的话，调度 Run 那两种手写类型就露在外面：
-	// `adjudication` 的 `subject` 是全服务唯一一个数字字段，没样例的调度智能体会写成
-	// 字符串然后吃一个 422；而日志只追加，它既改不了那条，也没有别的地方能学对。
-	sugar := map[model.FactType]bool{
-		model.FactDispatchIntent: true,
-		model.FactWaitingReason:  true,
-		model.FactHandoffToHuman: true,
-	}
-	for _, kind := range []model.ActorKind{model.ActorTaskRun, model.ActorSchedulerRun} {
-		for _, factType := range authz.WritableBy(kind) {
-			if sugar[factType] {
-				continue
-			}
-			path := filepath.Join("assets", "payload-examples", string(factType)+".json")
-			if _, err := os.Stat(path); err != nil {
-				t.Errorf("%s 缺样例，而 %s 要手写这份 payload：%v", factType, kind, err)
-			}
-		}
-	}
-}

package/bundle/skills/df-workbench/manifest.yaml

@@ -1,5 +0,0 @@
-id: df-workbench
-version: 1.0.0
-provides:
-  skill: df-workbench
-  cli: df-workbench