pactive 0.0.1-alpha.1 → 0.0.3-alpha.1

package/src/hosts/dsh/index.mjs

@@ -1,4 +1,4 @@
-// DSH host adapter (contract §2). argv is verbatim per design §1: acti owns a dedicated profile.
+// DSH host adapter (contract §2). argv is verbatim per design §1: pactive owns a dedicated profile.
 import { readFileSync, readdirSync, rmSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -17,7 +17,7 @@ export const MODE = 'profile';
 export const resolveExec = makeResolver('dsh', 'dsh');
 
 export function buildArgv({ pkgRoot, userArgs = [] }) {
-  return ['--profile', 'acti', ...userArgs];
+  return ['--profile', 'pactive', ...userArgs];
 }
 
 export function plan({ pkgRoot, env = process.env, userArgs = [] }) {
@@ -62,13 +62,13 @@ export function stateRoot(ctx = {}) {
 }
 
 export function installArgs({ pkgRoot }) {
-  return ['plugin', '--profile', 'acti', 'add', pkgRoot];
+  return ['plugin', '--profile', 'pactive', 'add', pkgRoot];
 }
 
 export function uninstallArgs({ pkgRoot }) {
   // pnpm removes by DEPENDENCY NAME, not by path: `pnpm remove /abs/path` exits 1 and leaves
   // the profile untouched (defect found 2026-11-05 via install→uninstall→residue probe).
-  return ['plugin', '--profile', 'acti', 'remove', packageName(pkgRoot)];
+  return ['plugin', '--profile', 'pactive', 'remove', packageName(pkgRoot)];
 }
 
 /** The dependency name that `install` registered (falls back to the package's own default). */
@@ -79,25 +79,25 @@ function packageName(pkgRoot) {
   } catch {
     // manifest unreadable: fall back to the contract name
   }
-  return 'acti';
+  return 'pactive';
 }
 
-/** Whether the acti profile currently exists (used to keep `uninstall` idempotent and quiet). */
+/** Whether the pactive profile currently exists (used to keep `uninstall` idempotent and quiet). */
 export function isInstalled({ env }) {
   const home = env.DSH_HOME || path.join(os.homedir(), '.dsh');
-  const manifest = path.join(home, 'profiles', 'acti', 'package.json');
+  const manifest = path.join(home, 'profiles', 'pactive', 'package.json');
   try {
     const pkg = JSON.parse(readFileSync(manifest, 'utf8'));
-    return Boolean(pkg?.dependencies?.acti) || (pkg?.dsh?.profile?.bundles || []).includes('acti');
+    return Boolean(pkg?.dependencies?.pactive) || (pkg?.dsh?.profile?.bundles || []).includes('pactive');
   } catch {
     return false;
   }
 }
 
-/** Remove the acti-owned DSH profile directory so `uninstall` leaves zero residue (I40). */
+/** Remove the pactive-owned DSH profile directory so `uninstall` leaves zero residue (I40). */
 export function cleanup({ env }) {
   const home = env.DSH_HOME || path.join(os.homedir(), '.dsh');
-  const profileDir = path.join(home, 'profiles', 'acti');
+  const profileDir = path.join(home, 'profiles', 'pactive');
   const manifest = path.join(profileDir, 'package.json');
   let pkg;
   try {
@@ -105,7 +105,7 @@ export function cleanup({ env }) {
   } catch {
     return { removed: false, reason: 'no-profile' };
   }
-  if (pkg.name !== 'dsh-profile-acti') {
+  if (pkg.name !== 'dsh-profile-pactive') {
     return { removed: false, reason: 'profile-not-owned' };
   }
   rmSync(profileDir, { recursive: true, force: true });
@@ -120,7 +120,7 @@ export function cleanup({ env }) {
 }
 
 export function verifyArgs({ pkgRoot }) {
-  return ['plugin', '--profile', 'acti', 'list'];
+  return ['plugin', '--profile', 'pactive', 'list'];
 }
 
 export function verifyMatch({ pkgRoot }, output) {

package/src/hosts/errors.mjs

@@ -1,17 +1,17 @@
 // Contract §2 error taxonomy.
-export class ActiError extends Error {
-  constructor(message, { code = 'ACTI_ERROR', exitCode = 1, cause } = {}) {
+export class PactiveError extends Error {
+  constructor(message, { code = 'PACTIVE_ERROR', exitCode = 1, cause } = {}) {
     super(message, cause === undefined ? undefined : { cause });
-    this.name = 'ActiError';
+    this.name = 'PactiveError';
     this.code = code;
     this.exitCode = exitCode;
   }
 }
 
 /** The host binary could not be found → CLI exit code 127. */
-export class HostMissingError extends ActiError {
+export class HostMissingError extends PactiveError {
   constructor(host, attempted = null) {
-    const envVar = `ACTI_${host.toUpperCase()}_BIN`;
+    const envVar = `PACTIVE_${host.toUpperCase()}_BIN`;
     super(
       `host binary for '${host}' not found${attempted ? ` (${attempted})` : ''} — install '${host}' or set ${envVar}`,
       { code: 'HOST_MISSING', exitCode: 127 },

package/src/hosts/pi/index.mjs

@@ -19,7 +19,7 @@ export function buildArgv({ pkgRoot, userArgs = [] }) {
     '--extension',
     path.join(pkgRoot, 'pi', 'extension.ts'),
     '--skill',
-    path.join(pkgRoot, 'pi', 'skills', 'acti'),
+    path.join(pkgRoot, 'pi', 'skills', 'pactive'),
     ...userArgs,
   ];
 }

package/src/hosts/shared/index.mjs

@@ -26,10 +26,10 @@ export function findOnPath(name, env = process.env) {
   return null;
 }
 
-/** env.ACTI_<HOST>_BIN → PATH lookup → throw HostMissingError (exit 127). */
+/** env.PACTIVE_<HOST>_BIN → PATH lookup → throw HostMissingError (exit 127). */
 export function makeResolver(host, binaryName) {
   return function resolveExec({ env = process.env } = {}) {
-    const override = env[`ACTI_${host.toUpperCase()}_BIN`];
+    const override = env[`PACTIVE_${host.toUpperCase()}_BIN`];
     if (override) {
       if (isExecutable(override)) return path.resolve(override);
       throw new HostMissingError(host, override);
@@ -60,5 +60,5 @@ export function unreachableReceipt(reason) {
 }
 
 export function defaultStateRoot(ctx = {}) {
-  return ctx.stateRoot ?? ctx.paths?.root ?? path.join(os.homedir(), '.acti');
+  return ctx.stateRoot ?? ctx.paths?.root ?? path.join(os.homedir(), '.pactive');
 }

package/bin/acti.mjs

@@ -1,439 +0,0 @@
-#!/usr/bin/env node
-// Acti CLI — contract §3 / design §6.
-//
-// Output discipline (design §6.3): machine-readable results (--print-plan, doctor --json,
-// --version) go to stdout; every human/diagnostic Acti text goes to stderr, so the stdout of a
-// spawned host is never polluted.
-import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-import { ActiError } from '../src/hosts/errors.mjs';
-
-const HOSTS = ['pi', 'opcteam', 'dsh'];
-const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
-const PKG_ROOT = path.resolve(CLI_DIR, '..');
-const FALLBACK_VERSION = '0.0.1-alpha.1';
-const STALE_LOCK_MS = 30 * 60 * 1000;
-
-function usage(io) {
-  io.write(`acti — proactive companion for Pi / OPCteam / DSH
-
-Usage:
-  acti <host> [args...]        run a host with acti injected (stdio inherited)
-  acti --print-plan <host>     print the launch plan as JSON (no side effects)
-  acti doctor [--json]         diagnose hosts, state root and permissions (read-only)
-  acti install <host>          register acti with a host (idempotent)
-  acti uninstall <host>        unregister acti and remove acti state residue
-  acti --version | -v          print the acti version
-  acti --help | -h             show this help
-
-Hosts: ${HOSTS.join(', ')}
-
-Environment:
-  ACTI_HOME          package root override (default: this package)
-  ACTI_STATE_DIR     acti state root override
-  ACTI_PI_BIN        override the pi executable
-  ACTI_OPCTEAM_BIN   override the opcteam executable
-  ACTI_DSH_BIN       override the dsh executable
-`);
-}
-
-function unknownHost(host, io) {
-  io.write(`acti: unknown host '${host}'\n`);
-  io.write(`acti: known hosts: ${HOSTS.join(', ')}\n`);
-}
-
-function resolvePkgRoot(env) {
-  return env.ACTI_HOME ? path.resolve(env.ACTI_HOME) : PKG_ROOT;
-}
-
-function actiVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
-    if (typeof pkg.version === 'string') return pkg.version;
-  } catch {
-    // package.json not built yet — fall back to the contract version
-  }
-  return FALLBACK_VERSION;
-}
-
-async function loadAdapter(host) {
-  return import(new URL(`../src/hosts/${host}/index.mjs`, import.meta.url));
-}
-
-/** src/core is built by the acti-core worker; until then the CLI degrades instead of faking it. */
-async function loadCore() {
-  try {
-    return await import(new URL('../src/core/index.mjs', import.meta.url));
-  } catch (err) {
-    throw new ActiError('ACTI core not built yet', { code: 'CORE_MISSING', exitCode: 1, cause: err });
-  }
-}
-
-async function resolveStateRoot(env, warnings = []) {
-  if (env.ACTI_STATE_DIR) return path.resolve(env.ACTI_STATE_DIR);
-  try {
-    const core = await loadCore();
-    const paths = core.resolvePaths('pi', env);
-    if (paths?.root) return paths.root;
-    warnings.push('ACTI core returned no state root — using the default location');
-  } catch (err) {
-    warnings.push(`${err.message} — using the default state root`);
-  }
-  return path.join(os.homedir(), '.acti');
-}
-
-function modeOf(p) {
-  return (statSync(p).mode & 0o777).toString(8).padStart(4, '0');
-}
-
-function probeVersion(exec) {
-  const res = spawnSync(exec, ['--version'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
-  const out = `${res.stdout ?? ''}${res.stderr ?? ''}`.trim();
-  if (!out) return null;
-  return out.split(/\s+/)[0];
-}
-
-function majorOf(version) {
-  const major = Number.parseInt(String(version).split('.')[0], 10);
-  return Number.isNaN(major) ? null : major;
-}
-
-function isCompatible(found, supported) {
-  if (!found || !supported) return false;
-  const a = majorOf(found);
-  const b = majorOf(supported);
-  return a !== null && b !== null && a === b;
-}
-
-function countFiles(dir) {
-  if (!existsSync(dir)) return 0;
-  let n = 0;
-  for (const name of readdirSync(dir)) {
-    const abs = path.join(dir, name);
-    if (statSync(abs).isDirectory()) n += countFiles(abs);
-    else n += 1;
-  }
-  return n;
-}
-
-function stateStats(stateRoot) {
-  const stats = {
-    exists: existsSync(stateRoot),
-    perm: { dir: null, file: null },
-    idle: { enabled: false },
-    sessions: 0,
-    tasks: 0,
-    outbox: 0,
-    locksStale: 0,
-    fails: [],
-  };
-  if (!stats.exists) return stats;
-
-  stats.perm.dir = modeOf(stateRoot);
-  if (stats.perm.dir !== '0700') {
-    stats.fails.push(`state root ${stateRoot} has mode ${stats.perm.dir}, expected 0700`);
-  }
-
-  const stateFile = path.join(stateRoot, 'state.json');
-  if (existsSync(stateFile)) {
-    stats.perm.file = modeOf(stateFile);
-    if (stats.perm.file !== '0600') {
-      stats.fails.push(`state file ${stateFile} has mode ${stats.perm.file}, expected 0600`);
-    }
-    try {
-      const state = JSON.parse(readFileSync(stateFile, 'utf8'));
-      stats.idle.enabled = Boolean(state?.idle?.enabled);
-      if (Array.isArray(state?.tasks)) stats.tasks = state.tasks.length;
-    } catch {
-      stats.fails.push(`state file ${stateFile} is not valid JSON`);
-    }
-  }
-
-  const tasksFile = path.join(stateRoot, 'tasks.json');
-  if (existsSync(tasksFile)) {
-    try {
-      const tasks = JSON.parse(readFileSync(tasksFile, 'utf8'));
-      if (Array.isArray(tasks)) stats.tasks = tasks.length;
-    } catch {
-      stats.fails.push(`tasks file ${tasksFile} is not valid JSON`);
-    }
-  }
-
-  stats.sessions = countFiles(path.join(stateRoot, 'peers'));
-  stats.outbox = countFiles(path.join(stateRoot, 'outbox'));
-
-  const locksDir = path.join(stateRoot, 'locks');
-  if (existsSync(locksDir)) {
-    const now = Date.now();
-    for (const name of readdirSync(locksDir)) {
-      const abs = path.join(locksDir, name);
-      if (statSync(abs).isFile() && now - statSync(abs).mtimeMs > STALE_LOCK_MS) stats.locksStale += 1;
-    }
-  }
-  return stats;
-}
-
-async function doctorReport(env) {
-  const warnings = [];
-  const stateRoot = await resolveStateRoot(env, warnings);
-  const hosts = [];
-  for (const host of HOSTS) {
-    const mod = await loadAdapter(host);
-    let present = false;
-    let version = null;
-    let compatible = false;
-    try {
-      const exec = mod.resolveExec({ env });
-      present = true;
-      version = probeVersion(exec);
-      compatible = isCompatible(version, mod.SUPPORTED_VERSION);
-      if (!version) {
-        warnings.push(`host ${host}: installed but its version could not be read`);
-      } else if (!compatible) {
-        warnings.push(`host ${host}: version ${version} differs from the supported ${mod.SUPPORTED_VERSION}`);
-      }
-    } catch (err) {
-      if (err.code !== 'HOST_MISSING') throw err;
-      warnings.push(`host ${host}: not installed (set ACTI_${host.toUpperCase()}_BIN to override)`);
-    }
-    hosts.push({ host, present, version, mode: mod.MODE, compatible });
-  }
-
-  const stats = stateStats(stateRoot);
-  if (!stats.exists) warnings.push(`state root ${stateRoot} does not exist yet`);
-  for (const fail of stats.fails) warnings.push(`FAIL: ${fail}`);
-
-  return {
-    ok: stats.fails.length === 0,
-    hosts,
-    stateRoot,
-    perm: stats.perm,
-    idle: { enabled: stats.idle.enabled, source: 'core-timeline' },
-    sessions: stats.sessions,
-    tasks: stats.tasks,
-    outbox: stats.outbox,
-    locksStale: stats.locksStale,
-    secrets: { credentialsRead: false },
-    warnings,
-  };
-}
-
-function printPlan(args, env, io) {
-  const host = args[0];
-  if (!host) {
-    unknownHost('', io.stderr);
-    return Promise.resolve(2);
-  }
-  if (!HOSTS.includes(host)) {
-    unknownHost(host, io.stderr);
-    return Promise.resolve(2);
-  }
-  return loadAdapter(host).then((mod) => {
-    const plan = mod.plan({ pkgRoot: resolvePkgRoot(env), env, userArgs: [] });
-    io.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
-    return 0;
-  });
-}
-
-function doctorCmd(args, env, io) {
-  const asJson = args.includes('--json');
-  return doctorReport(env).then((report) => {
-    if (asJson) {
-      io.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    } else {
-      io.stderr.write(`acti doctor: ${report.ok ? 'OK' : 'FAIL'}\n`);
-      io.stderr.write(`state root: ${report.stateRoot} (dir ${report.perm.dir}, file ${report.perm.file})\n`);
-      for (const h of report.hosts) {
-        io.stderr.write(
-          `host ${h.host}: present=${h.present} version=${h.version ?? 'unknown'} mode=${h.mode} compatible=${h.compatible}\n`,
-        );
-      }
-      io.stderr.write(
-        `sessions=${report.sessions} tasks=${report.tasks} outbox=${report.outbox} locksStale=${report.locksStale} idle.enabled=${report.idle.enabled}\n`,
-      );
-      for (const w of report.warnings) io.stderr.write(`- ${w}\n`);
-    }
-    return report.ok ? 0 : 1;
-  });
-}
-
-function runHostCommand(exec, args) {
-  const res = spawnSync(exec, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  return { status: res.status ?? 1, stdout: res.stdout ?? '', stderr: res.stderr ?? '' };
-}
-
-function verifyRegistered(mod, exec, pkgRoot) {
-  const res = runHostCommand(exec, mod.verifyArgs({ pkgRoot }));
-  return mod.verifyMatch({ pkgRoot }, `${res.stdout}\n${res.stderr}`);
-}
-
-const OWNED_STATE_ENTRIES = ['state.json', 'tasks.json', 'ledger.jsonl', 'peers', 'inbox', 'outbox', 'locks'];
-
-function removeStateResidue(stateRoot) {
-  if (!existsSync(stateRoot)) return [];
-  for (const name of OWNED_STATE_ENTRIES) {
-    rmSync(path.join(stateRoot, name), { recursive: true, force: true });
-  }
-  for (const name of readdirSync(stateRoot)) {
-    if (/^(state|tasks)\.json\.corrupt-/.test(name)) {
-      rmSync(path.join(stateRoot, name), { recursive: true, force: true });
-    }
-  }
-  const left = [];
-  const walk = (dir, rel) => {
-    for (const name of readdirSync(dir)) {
-      const abs = path.join(dir, name);
-      const relPath = rel ? path.join(rel, name) : name;
-      if (statSync(abs).isDirectory()) walk(abs, relPath);
-      else left.push(relPath);
-    }
-  };
-  walk(stateRoot, '');
-  return left;
-}
-
-function installCmd(args, env, io, action) {
-  const host = args[0];
-  if (!host) {
-    unknownHost('', io.stderr);
-    return Promise.resolve(2);
-  }
-  if (!HOSTS.includes(host)) {
-    unknownHost(host, io.stderr);
-    return Promise.resolve(2);
-  }
-  return loadAdapter(host).then(async (mod) => {
-    const exec = mod.resolveExec({ env });
-    const pkgRoot = resolvePkgRoot(env);
-    if (action === 'uninstall' && typeof mod.isInstalled === 'function') {
-      let installed = true;
-      try { installed = mod.isInstalled({ pkgRoot, env }); } catch { installed = true; }
-      if (!installed) {
-        // 幂等：没装就什么都不跑（跑宿主 remove 会让 DSH 重建 profile，制造"删了又出现"的怪象）
-        if (typeof mod.cleanup === 'function') {
-          try { mod.cleanup({ pkgRoot, env }); } catch { /* residue 清理失败由下方 residue 检查兜底 */ }
-        }
-        io.stderr.write(`acti: ${host} not installed — nothing to uninstall\n`);
-        return 0;
-      }
-    }
-    const argsFor = action === 'install' ? mod.installArgs({ pkgRoot }) : mod.uninstallArgs({ pkgRoot });
-    const res = runHostCommand(exec, argsFor);
-
-    if (res.status !== 0) {
-      const stillRegistered = verifyRegistered(mod, exec, pkgRoot);
-      if (action === 'install' ? !stillRegistered : stillRegistered) {
-        io.stderr.write(`acti: ${action} ${host} failed (exit ${res.status})\n`);
-        if (res.stderr.trim()) io.stderr.write(`${res.stderr.trim()}\n`);
-        return 1;
-      }
-    }
-
-    if (action === 'uninstall') {
-      // Host-level residue: adapters may own resources Acti created (e.g. the DSH profile dir).
-      if (typeof mod.cleanup === 'function') {
-        try {
-          const cleaned = mod.cleanup({ pkgRoot, env });
-          if (cleaned && cleaned.removed) io.stderr.write(`acti: removed ${cleaned.path}\n`);
-        } catch (err) {
-          io.stderr.write(`acti: cleanup warning: ${err?.message ?? err}\n`);
-        }
-      }
-      const stateRoot = await resolveStateRoot(env, []);
-      const residue = removeStateResidue(stateRoot);
-      if (residue.length > 0) {
-        io.stderr.write(`acti: residue left in ${stateRoot}: ${residue.join(', ')}\n`);
-        return 1;
-      }
-    }
-
-    io.stderr.write(`acti: ${action} ${host} ok (${pkgRoot})\n`);
-    return 0;
-  });
-}
-
-function runHost(host, userArgs, env, io) {
-  return loadAdapter(host).then((mod) => {
-    const exec = mod.resolveExec({ env });
-    const pkgRoot = resolvePkgRoot(env);
-    const argv = mod.buildArgv({ pkgRoot, userArgs });
-    io.stderr.write(`acti: launching ${host} (${exec})\n`);
-    return new Promise((resolve) => {
-      const child = spawn(exec, argv, { stdio: 'inherit', env });
-      const forward = (sig) => {
-        if (!child.killed) child.kill(sig);
-      };
-      process.on('SIGINT', forward);
-      process.on('SIGTERM', forward);
-      child.on('error', (err) => {
-        io.stderr.write(`acti: failed to launch ${host}: ${err.message}\n`);
-        resolve(err.code === 'ENOENT' ? 127 : 1);
-      });
-      child.on('exit', (code, signal) => {
-        process.off('SIGINT', forward);
-        process.off('SIGTERM', forward);
-        resolve(signal ? 128 + (os.constants.signals[signal] ?? 0) : (code ?? 0));
-      });
-    });
-  });
-}
-
-export async function main(argv, env = process.env, io = { stdout: process.stdout, stderr: process.stderr }) {
-  const args = argv.slice(2);
-  if (args.length === 0) {
-    usage(io.stderr);
-    return 2;
-  }
-  const [cmd, ...rest] = args;
-  switch (cmd) {
-    case '--version':
-    case '-v':
-      io.stdout.write(`${actiVersion()}\n`);
-      return 0;
-    case '--help':
-    case '-h':
-      usage(io.stderr);
-      return 0;
-    case '--print-plan':
-      return printPlan(rest, env, io);
-    case 'doctor':
-      return doctorCmd(rest, env, io);
-    case 'install':
-      return installCmd(rest, env, io, 'install');
-    case 'uninstall':
-      return installCmd(rest, env, io, 'uninstall');
-    default:
-      break;
-  }
-  if (!HOSTS.includes(cmd)) {
-    unknownHost(cmd, io.stderr);
-    return 2;
-  }
-  return runHost(cmd, rest, env, io);
-}
-
-// Entry guard: compare REAL paths. Installed bin shims and macOS /tmp are symlinks, so
-// `process.argv[1]` and `import.meta.url` differ textually when they point at the same file —
-// a plain string compare silently turns the CLI into a no-op (defect found 2026-11-05 via install chain).
-const isMain = (() => {
-  try {
-    const self = realpathSync(fileURLToPath(import.meta.url));
-    const argv1 = realpathSync(process.argv[1]);
-    return self === argv1;
-  } catch {
-    return false;
-  }
-})();
-if (isMain) {
-  try {
-    process.exitCode = await main(process.argv, process.env, { stdout: process.stdout, stderr: process.stderr });
-  } catch (err) {
-    const exitCode = err instanceof ActiError ? err.exitCode : 1;
-    process.stderr.write(`acti: ${err?.message ?? err}\n`);
-    process.exitCode = exitCode;
-  }
-}

package/commands/acti.md

@@ -1,46 +0,0 @@
----
-description: Acti 主动机制 — status、schedule、tell、history（经 acti MCP server）
-argument-hint: "[status|schedule|tell|history] [args...]"
----
-
-# acti:acti
-
-把用户关于「主动机制 / 空闲触发 / 定时任务 / 跨会话消息」的请求路由到 `acti` MCP server。
-宿主把它暴露为 `/acti:acti`；裸 `/acti` 不由插件契约保证。
-
-## 工具名
-
-OPCteam 用命名空间暴露插件 MCP 工具：
-
-```
-mcp__plugin_acti_acti__<tool>
-```
-
-具体名字：
-
-- `mcp__plugin_acti_acti__acti_status`
-- `mcp__plugin_acti_acti__acti_schedule`
-- `mcp__plugin_acti_acti__acti_tell`
-- `mcp__plugin_acti_acti__acti_history`
-
-裸名（`acti_status`）不一定能被 ToolSearch 发现；若命名空间工具没加载，用
-`select:mcp__plugin_acti_acti__acti_status` 搜一次。
-
-## 路由
-
-| 用户说 | 调用 |
-|---|---|
-| 状态 / 为什么没触发 | `acti_status`（看 `idle.reason`，别猜） |
-| 10 分钟后提醒我 / 定时 | `acti_schedule` `when:"10m"` `prompt:"…"` |
-| 18:30 提醒我 | `acti_schedule` `when:"18:30"` |
-| 每小时 | `acti_schedule` `when:"every 1h"` |
-| 告诉另一个会话 | `acti_tell` `to` `body`（可选 `kind:"ask"`） |
-| 最近发生过什么 | `acti_history` `limit` |
-
-## 硬规则
-
-1. **不要替用户改配置**：acti 的开关与配置是人工闸门（CLI `--confirm`）。用户要求改配置时，
-   告诉他用 `acti config set … --confirm`，不要自行绕过。
-2. **回执如实转述**：`queued` 就是**还没送到**（对端离线），不要说成已送达。
-3. **默认不打扰**：空闲触发默认关闭；用户没明确要「空闲自动推进」时，不要假设它已开启。
-4. **只报新事实**：状态类输出要给出 `idle.reason` 与护栏结论，不要泛泛说「一切正常」。

package/pi/skills/acti/SKILL.md

@@ -1,47 +0,0 @@
----
-name: acti
-description: >-
-  Correct usage of the acti proactive-assistant extension (tools acti_status / acti_schedule /
-  acti_tell / acti_history and the "/acti" command family). Use when the task involves checking
-  whether the idle trigger fired or why it did not, scheduling work for later (one-shot or
-  repeating), reading the acti event ledger, or sending a message to another session on the same
-  machine. Covers the semantics traps (queued is not delivered, idle is disabled by default,
-  human-gated config needs CLI --confirm, the Stop hook blocks at most once per turn) and the
-  "when" syntax (10m / 18:30 / ISO 8601 / every 1h).
----
-
-# acti：怎么正确用它
-
-acti 给会话加**主动机制**：空闲判定（到点才动手）、**定时任务**、**跨会话消息**与**事件账本**。
-
-## 工具与命令
-
-| 入口 | 作用 |
-|---|---|
-| `acti_status` / `/acti status` | 空闲判定与 `reason`、护栏四闸门、定时任务数、最近活动（只读） |
-| `acti_schedule` / `/acti schedule <when> <prompt>` | 登记一个定时任务（真正落盘，重启后仍在） |
-| `acti_tell <to> <body>` | 给同机另一个会话投递消息（离线时排队，不伪装成功） |
-| `acti_history [n]` | 读事件账本尾部：触发 → 投递 → 回应 → 结账 |
-| `/acti tasks` | 列出待触发的定时任务 |
-
-## 关键语义（别踩）
-
-- **默认不打扰**：`idle.enabled` 默认 `false`。没打开开关，空闲永远不会触发主动行为。
-- **`reason` 是枚举**：`idle | disabled | no-control | busy | threshold | quiet | hourly-limit | min-interval | cooldown | requires-action`。
-  没触发时先看 `reason`，不要猜。
-- **四闸门缺一不可**：控制权已交回 + 不忙 + 超过阈值 + 护栏通过，才可能触发。
-- **`queued` ≠ 已送达**：对端离线时消息进 outbox，等对端上线再补投；回执写 `queued` 就是还没送到。
-- **配置是人工闸门**：`config` 只能由人用 CLI `--confirm` 改；模型/MCP 侧改配置一律得到
-  `need_human_confirmation`，且配置不变。
-- **Stop hook 最多阻断一次**：同一轮里只阻断一次，避免死循环；`UserPromptSubmit` 会重置这个计数。
-
-## `when` 语法
-
-`10m` / `2h` / `30s`（相对时长）、`18:30`（当天时刻，已过则顺延到明天）、
-ISO 8601 时间戳（绝对时刻）、`every 1h`（周期）。缺省 `10m`。
-
-## 排障
-
-- 状态面板里 `reason=disabled` → 开关没开；`reason=busy` → 宿主还在忙；`reason=threshold` → 还没到阈值。
-- 任务登记了但没触发 → 先看 `acti_history` 里有没有 `triggered` 记录；没有说明调度器没跑到。
-- 消息一直是 `queued` → 对端不在线；看 `acti_status` 的 peers。