@yijiancaotang/cli 1.0.0 → 1.2.0

package/dist/local-commands.js

@@ -1,17 +1,19 @@
 import { shellWord } from "./agent-identity.js";
 import { constants } from "node:fs";
 import { open } from "node:fs/promises";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { authLogin } from "./auth.js";
 import { doctor } from "./doctor.js";
 import { CliError, asRecord } from "./errors.js";
-import { inspectLocalInstallation, installLocal } from "./installation.js";
+import { inspectLocalInstallation, inspectManagedOrigins, installLocal } from "./installation.js";
 import { isPlatformId, platformSupported } from "./local-types.js";
-import { detectPlatforms } from "./platforms.js";
+import { detectPlatforms, explicitSkillsTarget, knownSkillTargets } from "./platforms.js";
 import { loadSkillAssets } from "./skill-assets.js";
+import { LocalRecords } from "./local-records.js";
 import { defaultConnectionNames, inspectAccountState, onboardingMessage } from "./onboarding.js";
-import { setupFailureMessage } from "./connection-copy.js";
+import { connectionCopy, setupFailureMessage } from "./connection-copy.js";
+import { setupGuidance } from "./setup-guidance.js";
 const root = () => fileURLToPath(new URL("../", import.meta.url));
 const invalid = () => new CliError("invalid_arguments", "命令或参数无效。", "运行 --help；平台支持claude-code、codex、openclaw，以及仅macOS支持的kimi-code、kimi-work和workbuddy。");
 export function selectedPlatforms(value, operatingSystem = process.platform) {
@@ -26,6 +28,15 @@ export function selectedPlatforms(value, operatingSystem = process.platform) {
         throw new CliError("platform_unsupported", "所选新增平台尚不支持当前系统。", "kimi-code、kimi-work和workbuddy仅支持macOS本机安装；不要套用或猜测其它系统的技能目录。");
     return values;
 }
+export function selectedSkillsDirectory(flags) {
+    const value = flags["skills-dir"];
+    if (value === undefined)
+        return undefined;
+    if (flags.platform !== undefined || typeof value !== "string" || !value.trim() || !isAbsolute(value)
+        || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value))
+        throw new CliError("invalid_arguments", "--skills-dir须为明确的绝对父目录，且不能与--platform同时使用。", "指定七项技能子目录的共同父目录；不提供配置内容，不以此绑定项目。", 2);
+    return value;
+}
 export async function localVersion(packageRoot = root()) {
     const failed = () => new CliError("version_unavailable", "无法核对当前命令行版本。", "请使用完整的一间草堂命令行构建；不要运行不明升级脚本。", 7);
     try {
@@ -53,33 +64,110 @@ export async function localVersion(packageRoot = root()) {
 export function manualUpdateInstructions() {
     return { status: 200, body: { operation: "update", update_policy: "manual", next_action: "运行 npx @yijiancaotang/cli@latest setup --agent <你的名字> 更新到最新版。" } };
 }
-async function targetsFor(ctx, ids, setup) {
+function connectionTimeInBeijing(value) {
+    if (!value)
+        return undefined;
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        return undefined;
+    const parts = new Intl.DateTimeFormat("en-GB", {
+        timeZone: "Asia/Shanghai", year: "numeric", month: "2-digit", day: "2-digit",
+        hour: "2-digit", minute: "2-digit", hourCycle: "h23",
+    }).formatToParts(timestamp);
+    const fields = Object.fromEntries(parts.map(part => [part.type, part.value]));
+    return `${fields.year}-${fields.month}-${fields.day} ${fields.hour}:${fields.minute}`;
+}
+const recordsFor = (ctx) => ctx.agent ? new LocalRecords(ctx.homeDir, ctx.agent, ctx.auth.environment ?? "production", new URL(ctx.auth.api.baseUrl).origin) : undefined;
+async function targetsFor(ctx, ids, setup, assets, recorded, skillsDirectory) {
+    const inspect = (targets) => inspectManagedOrigins({ ...ctx, agentName: ctx.agent?.key, assets, targets });
+    if (skillsDirectory !== undefined) {
+        const target = await explicitSkillsTarget({ homeDir: ctx.homeDir, skillsDirectory });
+        return { targets: [target], origins: await inspect([target]) };
+    }
+    if (ids === undefined && recorded.some(target => target.id === "generic")) {
+        if (recorded.length !== 1)
+            throw new CliError("skill_target_ambiguous", "这个名字记录了多个技能目录，未自动选择。", "请保留本次明确的--skills-dir或--platform参数；不会批量更新不同工作区。", 2);
+        const target = await explicitSkillsTarget({ homeDir: ctx.homeDir, skillsDirectory: recorded[0].skillDirectory });
+        return { targets: [target], origins: await inspect([target]) };
+    }
+    recorded = recorded.filter(target => isPlatformId(target.id));
     if (ctx.agent) {
         if (ids && ids.length !== 1)
             throw new CliError("invalid_arguments", "每次接入只给一个 AI 平台安装技能。", "请带自己的 --agent 名字，一次只选一个 --platform；其它 AI 分别接入。");
-        ids = ids ?? (ctx.agent.platform ? [ctx.agent.platform] : []);
-        if (!ids.length)
-            return [];
+        if (ids === undefined && recorded.length === 0) {
+            const candidates = await knownSkillTargets({ ...ctx, skipInvalidCandidates: true }), origins = await inspect(candidates);
+            const own = candidates.filter(target => origins.platforms.some(platform => platform.id === target.id && platform.skill_directory === target.skillDirectory && platform.ownKnownCount > 0))
+                .map(target => ({ ...target, detected: true, evidence: "skills" }));
+            if (own.length > 0 || !ctx.agent.platform)
+                return { targets: own, origins };
+        }
+        ids = ids ?? (recorded.length ? recorded.map(target => target.id).filter(isPlatformId) : ctx.agent.platform ? [ctx.agent.platform] : []);
+    }
+    const redirected = (id) => id === "claude-code" ? ctx.env.CLAUDE_CONFIG_DIR !== undefined
+        : id === "openclaw" ? ctx.env.OPENCLAW_STATE_DIR !== undefined || ctx.env.OPENCLAW_HOME !== undefined
+            : id === "kimi-code" && ctx.env.KIMI_CODE_HOME !== undefined;
+    const preferred = recorded.filter(target => isPlatformId(target.id) && (!ids || ids.includes(target.id)) && !redirected(target.id));
+    if (preferred.some(target => isPlatformId(target.id) && !platformSupported(target.id, ctx.operatingSystem)))
+        throw new CliError("platform_unsupported", "已记录的技能平台不支持当前系统。", "请在原支持的系统上检查该平台；不会猜测新目录或搬动技能。", 2);
+    const discoveryIds = ids?.filter(id => !preferred.some(target => target.id === id));
+    // A recorded custom target must not cause inspection of an unrelated default
+    // directory just to rediscover the same platform.
+    const discovered = discoveryIds?.length === 0 ? [] : await detectPlatforms({ homeDir: ctx.homeDir, env: ctx.env, applicationRoots: ctx.applicationRoots, operatingSystem: ctx.operatingSystem, platformIds: discoveryIds });
+    const all = [...preferred.map(target => ({ ...target })), ...discovered];
+    const origins = await inspect(all);
+    for (const target of all) {
+        if (ctx.agent && !target.detected && origins.platforms.some(platform => platform.id === target.id && platform.skill_directory === target.skillDirectory && platform.ownKnownCount > 0)) {
+            target.detected = true;
+            target.evidence = "skills";
+        }
     }
-    const all = await detectPlatforms({ homeDir: ctx.homeDir, env: ctx.env, applicationRoots: ctx.applicationRoots, operatingSystem: ctx.operatingSystem, platformIds: ids });
-    return ids ? all.filter(target => ids.includes(target.id)) : setup ? all.filter(target => target.detected) : all;
+    return { targets: ids ? all.filter(target => isPlatformId(target.id) && ids.includes(target.id)) : setup ? all.filter(target => target.detected) : all, origins };
 }
 export async function localDoctor(ctx, flags, authFailure) {
+    const skillsDirectory = selectedSkillsDirectory(flags);
     return doctor({
         auth: ctx.auth, authFailure, agent: ctx.agent,
         inspectLocal: async () => {
             const assets = await loadSkillAssets(ctx.packageRoot ?? root());
-            return inspectLocalInstallation({ ...ctx, agentName: ctx.agent?.key, assets, targets: await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), false) });
+            const recorded = skillsDirectory === undefined ? await recordsFor(ctx)?.targets() ?? [] : [];
+            const selection = await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), false, assets, recorded, skillsDirectory);
+            const inspected = await inspectLocalInstallation({ ...ctx, agentName: ctx.agent?.key, assets, targets: selection.targets });
+            const platforms = inspected.platforms.map(platform => {
+                const origin = selection.origins.platforms.find(origin => origin.id === platform.id && origin.skill_directory === platform.skill_directory);
+                return origin ? { ...platform, skills: origin.skills } : platform;
+            });
+            const issues = inspected.issues.filter(issue => !["skill_missing", "skill_modified", "skill_unsafe"].includes(issue.code));
+            let command = inspected.command;
+            if (selection.origins.command.legacyManaged) {
+                command = { ...command, installed: true, ...selection.origins.command };
+                for (let index = issues.length - 1; index >= 0; index--)
+                    if (issues[index].code === "command_modified")
+                        issues.splice(index, 1);
+                issues.push({ code: "command_outdated", message: "已核对为旧版受管命令行，需要更新。", next_action: "沿用原来的名字运行 npx @yijiancaotang/cli@latest setup --agent <你的名字> 更新，不需要重新批准连接。" });
+            }
+            const skillPlatforms = selection.targets.filter(target => recorded.some(record => record.id === target.id && record.skillDirectory === target.skillDirectory)
+                || selection.origins.platforms.some(origin => origin.id === target.id && origin.skill_directory === target.skillDirectory && origin.ownKnownCount > 0)).map(target => target.id);
+            return { ...inspected, command, platforms, issues, skill_platforms: skillPlatforms };
         },
     });
 }
 export async function localSetup(ctx, flags) {
-    const assets = await loadSkillAssets(ctx.packageRoot ?? root()), targets = await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), true);
+    const skillsDirectory = selectedSkillsDirectory(flags);
+    const records = recordsFor(ctx), recorded = skillsDirectory === undefined ? await records?.targets() ?? [] : [];
+    const assets = await loadSkillAssets(ctx.packageRoot ?? root()), { targets } = await targetsFor(ctx, selectedPlatforms(flags.platform, ctx.operatingSystem), true, assets, recorded, skillsDirectory);
     const local = { ...ctx, agentName: ctx.agent?.key, assets, targets };
     const installed = await installLocal(local);
+    await records?.rememberInstallation(targets, assets, installed.bundleSha);
+    for (const target of targets) {
+        if (!target.detected) {
+            target.detected = true;
+            target.evidence = "skills";
+        }
+    }
     const newEntries = installed.newlyInstalledPlatforms;
     let authFailure;
     let authorizationAttempted = false;
+    const currentSecrets = new Set(ctx.auth.tokenOverride ? [ctx.auth.tokenOverride] : []);
     // Observe the actual start request after authLogin's credential/abort checks.
     // Validation and doctor requests do not constitute a new authorization attempt.
     const observedAuth = {
@@ -89,6 +177,8 @@ export async function localSetup(ctx, flags) {
             request(path, options) {
                 if (path === "/api/v1/agent/device-auth/start" && options?.method === "POST")
                     authorizationAttempted = true;
+                if (path === "/api/v1/agent/mcp-token/validate" && typeof options?.token === "string")
+                    currentSecrets.add(options.token);
                 return ctx.auth.api.request(path, options);
             },
             upload: (url, headers, bytes) => ctx.auth.api.upload(url, headers, bytes),
@@ -97,10 +187,12 @@ export async function localSetup(ctx, flags) {
     };
     let newAuthorizationOwner;
     let loginIdentity;
+    let loginResult = null;
     const names = defaultConnectionNames(targets.map(target => target.id), ctx.computerName, ctx.agent?.name);
     try {
         const login = await authLogin(observedAuth, { device_name: flags["device-name"] ?? names.deviceName, client_name: flags["client-name"] ?? names.clientName, noOpen: flags["no-open"] === true });
         const who = asRecord(login.body);
+        loginResult = who;
         if (typeof who?.user_id === "string" && typeof who.token_id === "string" && (who.kind === "manual" || who.kind === "device") && (who.scope === "read_only" || who.scope === "read_write")) {
             loginIdentity = { userId: who.user_id, tokenId: who.token_id, kind: who.kind, scope: who.scope };
         }
@@ -111,7 +203,7 @@ export async function localSetup(ctx, flags) {
         authFailure = error instanceof CliError ? error : new CliError("authorization_delivery_unknown", "无法确认授权操作的结果。", "先在网页核对并吊销未保存的设备，不要自动重新签发。", 6);
     }
     let checkedIdentity;
-    const report = await doctor({ auth: ctx.auth, authFailure, agent: ctx.agent, inspectLocal: () => inspectLocalInstallation(local), onIdentity: who => { checkedIdentity = who; } });
+    const report = await doctor({ auth: ctx.auth, authFailure, agent: ctx.agent, inspectLocal: async () => ({ ...await inspectLocalInstallation(local), skill_platforms: targets.map(target => target.id) }), onIdentity: who => { checkedIdentity = who; } });
     const body = asRecord(report.result.body);
     if (!body)
         throw new CliError("diagnostic_unavailable", "本地安装已执行，但无法确认最终诊断。", "先运行doctor只读核对，不要直接重新授权。", 7);
@@ -129,8 +221,33 @@ export async function localSetup(ctx, flags) {
     const accountState = newEntries.length && body.ready === true && checkedIdentity ? await inspectAccountState(ctx.auth, checkedIdentity.userId) : "unknown";
     const greeting = body.ready === true && checkedIdentity ? onboardingMessage(newEntries, accountState, checkedIdentity.scope)
         : { account_state: "unknown", onboarding: { action: "none", newly_connected_platforms: [] }, user_message: setupFailureMessage(identityChanged ? "authorization_identity_changed" : authFailure?.code) };
+    const reused = Boolean(sameConnection && loginResult?.reused_existing === true);
+    let connection;
+    if (sameConnection && ctx.agent && checkedIdentity) {
+        if (reused) {
+            connection = ctx.auth.tokenOverride !== undefined ? { connection_name: ctx.agent.key, connection_name_source: "environment_override" }
+                : await records?.connection(checkedIdentity.tokenId, [...currentSecrets]) ?? { connection_name: ctx.agent.key, connection_name_source: "local_agent_key" };
+        }
+        else if (body.ready === true && loginResult?.new_authorization_confirmed === true && typeof loginResult.connection_name === "string" && typeof loginResult.connected_at === "string") {
+            connection = { connection_name: loginResult.connection_name, connection_name_source: "local_authorization_record", connected_at: loginResult.connected_at, connection_time_source: "device_authorization" };
+            await records?.rememberConnection(checkedIdentity.tokenId, connection, [...currentSecrets]);
+        }
+    }
+    const onboardingCopy = reused && checkedIdentity && (connection?.connection_name_source !== "environment_override"
+        ? greeting.onboarding.action !== "none" || checkedIdentity.scope === "read_only"
+        : greeting.onboarding.action === "none" && checkedIdentity.scope === "read_only")
+        ? { onboarding_message: greeting.onboarding.action !== "none" ? greeting.user_message : connectionCopy.read_only } : {};
+    const connectionDisplayTime = connectionTimeInBeijing(connection?.connected_at);
+    const reuseCopy = reused && connection && connection.connection_name_source !== "environment_override" ? {
+        user_message: "这个名字已经接过了，沿用原来的连接，不用再批准。",
+        next_action: `已沿用名为 ${connection.connection_name} 的连接${connectionDisplayTime ? `（${connectionDisplayTime} 接入）` : ""}。如果你不是它，请用你自己的名字重新运行 setup --agent <你的名字>，不要继续用这条连接。`,
+        ...(connection.connection_name_source === "local_agent_key" ? { connection_name_note: "本机仅记有规范化名字，原连接名称和接入时间未记录。" } : {}),
+    } : reused && connection?.connection_name_source === "environment_override" ? {
+        reuse_notice: "本次沿用环境中提供的授权，不是本机保存的同名连接。若要独立接入，请由本人先处理环境授权覆盖，再用自己的名字运行 setup --agent <你的名字>。",
+    } : {};
     return { exitCode: report.exitCode, result: { status: 200, body: { ...body, operation: "setup", local_installation: { changed: installed.changed, bundle_sha: installed.bundleSha }, authorization_attempted: authorizationAttempted,
-                new_authorization_confirmed: confirmed, ...(confirmed ? { new_authorization_owner_id: newAuthorizationOwner } : {}), ...greeting,
-                ...(ctx.agent && !targets.length ? { generic_usage: { message: "这个 AI 没有专用技能安装位置；请按下列命令使用自己的连接。", commands: ["doctor", "context --start", "projects", "knowledge", "search", "auth status"].map(command => `caotang --agent ${shellWord(ctx.agent.name)} ${command}`) } } : {}),
-                ...(body.ready === true ? { next_conversation: "请开新对话说‘开工了’。" } : {}) } } };
+                new_authorization_confirmed: confirmed, ...(confirmed ? { new_authorization_owner_id: newAuthorizationOwner } : {}), reused_existing: reused, ...connection, ...greeting, ...onboardingCopy, ...reuseCopy,
+                guidance: setupGuidance({ ready: body.ready === true, connectionVerified: Boolean(sameConnection), agentName: ctx.agent?.name, environment: ctx.auth.environment, baseUrl: ctx.auth.api.baseUrl, credentialOrigin: ctx.auth.store.origin, scope: checkedIdentity?.scope }),
+                ...(ctx.agent && !targets.length ? { generic_usage: { message: "暂未定位到这个名字的专用技能；若曾使用自定义目录，请保留原目录参数再检查。仍可按下列命令使用自己的连接；context --handoff接手需服务端支持新协议，仅本人明确开工才用context --start。", commands: ["doctor", "context --handoff", "projects", "knowledge", "search", "auth status"].map(command => `caotang --agent ${shellWord(ctx.agent.name)} ${command}`) } } : {}),
+                ...(body.ready === true ? { next_conversation: "可以直接说‘看看草堂里的某个项目’；无需固定口令。" } : {}) } } };
 }

package/dist/local-records.js

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { join, relative, resolve, sep, isAbsolute } from "node:path";
+import { asRecord, CliError } from "./errors.js";
+import { OwnedTree } from "./installation.js";
+import { isSkillTargetId } from "./local-types.js";
+import { bindSkillAgent, completeSkillInventory } from "./skill-assets.js";
+const unsafe = () => new CliError("local_record_unsafe", "本机连接说明或技能安装记录未通过核对。", "保留现有连接和文件，先由本人核对本机记录；不要重新批准、覆盖或删除。", 7);
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const keys = (value, expected) => Object.keys(value).sort().join(",") === [...expected].sort().join(",");
+const id = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+const hash = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+const label = (value) => typeof value === "string" && value.trim() === value && [...value].length >= 1 && [...value].length <= 80 && !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value) && !/[^\S ]/u.test(value);
+const date = (value) => typeof value === "string" && /^\d{4}-\d\d-\d\dT/.test(value) && Number.isFinite(Date.parse(value));
+// These records contain no credentials. Immutable, content-addressed receipts
+// retain upgrade history; identical setup never rewrites or accumulates files.
+// They document installation, and never authorize overwriting a skill.
+export class LocalRecords {
+    agent;
+    environment;
+    origin;
+    tree;
+    connectionDirectory;
+    skillDirectory;
+    constructor(home, agent, environment, origin) {
+        this.agent = agent;
+        this.environment = environment;
+        this.origin = origin;
+        this.tree = new OwnedTree(home);
+        this.connectionDirectory = join(this.tree.home, ".caotang", "connection-info", environment, agent.fileKey);
+        this.skillDirectory = join(this.tree.home, ".caotang", "skill-receipts", agent.fileKey);
+    }
+    async read(path) {
+        try {
+            const bytes = await this.tree.read(path, 32768);
+            if (!bytes)
+                return null;
+            const value = asRecord(JSON.parse(bytes.toString("utf8")));
+            if (!value)
+                throw unsafe();
+            return value;
+        }
+        catch {
+            throw unsafe();
+        }
+    }
+    async connection(tokenId, secrets = []) {
+        if (!id(tokenId))
+            throw unsafe();
+        const record = await this.read(join(this.connectionDirectory, `${tokenId}.json`));
+        if (!record)
+            return null;
+        const connectionName = record.connection_name;
+        if (!keys(record, ["version", "environment", "origin", "agent_key", "token_id", "connection_name", "connected_at"])
+            || record.version !== 1 || record.environment !== this.environment || record.origin !== this.origin || record.agent_key !== this.agent.key || record.token_id !== tokenId
+            || !label(connectionName) || !date(record.connected_at) || secrets.some(secret => secret.length >= 8 && connectionName.includes(secret)))
+            throw unsafe();
+        return { connection_name: connectionName, connection_name_source: "local_authorization_record", connected_at: record.connected_at, connection_time_source: "device_authorization" };
+    }
+    async rememberConnection(tokenId, info, secrets = []) {
+        if (!id(tokenId) || info.connection_name_source !== "local_authorization_record" || !label(info.connection_name) || !date(info.connected_at)
+            || secrets.some(secret => secret.length >= 8 && info.connection_name.includes(secret)))
+            throw unsafe();
+        const record = { version: 1, environment: this.environment, origin: this.origin, agent_key: this.agent.key, token_id: tokenId, connection_name: info.connection_name, connected_at: info.connected_at };
+        try {
+            await this.tree.writeNew(join(this.connectionDirectory, `${tokenId}.json`), Buffer.from(JSON.stringify(record)), 0o600);
+        }
+        catch {
+            throw unsafe();
+        }
+    }
+    targetPath(path) {
+        if (typeof path !== "string" || !path || isAbsolute(path) || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(path))
+            throw unsafe();
+        const absolute = this.tree.within(join(this.tree.home, path));
+        if (absolute === this.tree.home || relative(this.tree.home, absolute) !== path || path.split(sep).includes(".."))
+            throw unsafe();
+        return absolute;
+    }
+    async targets() {
+        let names;
+        try {
+            names = await this.tree.list(this.skillDirectory);
+        }
+        catch {
+            throw unsafe();
+        }
+        if (!names)
+            return [];
+        if (names.length > 256)
+            throw unsafe();
+        const targets = new Map();
+        for (const name of names) {
+            if (!/^[a-z-]+\.[a-f0-9]{64}\.json$/.test(name))
+                throw unsafe();
+            const value = await this.read(join(this.skillDirectory, name));
+            if (!value || !keys(value, ["version", "agent_key", "platform", "skill_directory", "bundle_sha", "skills"]) || value.version !== 1 || value.agent_key !== this.agent.key
+                || typeof value.platform !== "string" || !isSkillTargetId(value.platform) || !hash(value.bundle_sha) || !Array.isArray(value.skills)
+                || !value.skills.every(item => { const entry = asRecord(item); return entry && keys(entry, ["name", "sha256"]) && typeof entry.name === "string" && hash(entry.sha256); })
+                || !completeSkillInventory(value.skills.map(item => item.name)) || name !== `${value.platform}.${digest(JSON.stringify(value))}.json`)
+                throw unsafe();
+            const skillDirectory = this.targetPath(value.skill_directory);
+            try {
+                await this.tree.list(skillDirectory);
+            }
+            catch {
+                throw unsafe();
+            }
+            // A retained receipt cannot make a removed directory appear installed.
+            // Keep the target so the ordinary inspector reports its missing skills.
+            const target = { id: value.platform, skillDirectory, detected: true, evidence: "skills" };
+            const key = target.id === "generic" ? `${target.id}\0${target.skillDirectory}` : target.id;
+            const previous = targets.get(key);
+            if (previous && previous.skillDirectory !== target.skillDirectory)
+                throw unsafe();
+            targets.set(key, target);
+        }
+        return [...targets.values()];
+    }
+    async rememberInstallation(targets, assets, bundleSha) {
+        if (!hash(bundleSha) || !completeSkillInventory(assets.map(asset => asset.name)))
+            throw unsafe();
+        for (const target of targets) {
+            const bound = assets.map(asset => bindSkillAgent(asset, this.agent.key));
+            if (!await verifiedSkillFiles(this.tree.home, target, bound))
+                throw unsafe();
+            const record = { version: 1, agent_key: this.agent.key, platform: target.id, skill_directory: relative(this.tree.home, resolve(target.skillDirectory)), bundle_sha: bundleSha, skills: bound.map(({ name, sha256 }) => ({ name, sha256 })) };
+            this.targetPath(record.skill_directory);
+            try {
+                await this.tree.writeNew(join(this.skillDirectory, `${target.id}.${digest(JSON.stringify(record))}.json`), Buffer.from(JSON.stringify(record)), 0o600);
+            }
+            catch {
+                throw unsafe();
+            }
+        }
+    }
+}
+export async function verifiedSkillFiles(home, target, assets) {
+    const tree = new OwnedTree(home);
+    if (!completeSkillInventory(assets.map(asset => asset.name)))
+        return false;
+    for (const asset of assets) {
+        const directory = join(target.skillDirectory, asset.name), entries = await tree.list(directory);
+        if (!entries || entries.length !== 1 || entries[0] !== "SKILL.md")
+            return false;
+        const bytes = await tree.read(join(directory, "SKILL.md"), 65536);
+        if (!bytes || digest(bytes) !== asset.sha256)
+            return false;
+    }
+    return true;
+}

package/dist/local-types.js

@@ -1,3 +1,4 @@
 export const PLATFORM_IDS = ["claude-code", "codex", "openclaw", "kimi-code", "kimi-work", "workbuddy"];
+export const isSkillTargetId = (value) => value === "generic" || isPlatformId(value);
 export const isPlatformId = (value) => PLATFORM_IDS.some(id => id === value);
 export const platformSupported = (id, operatingSystem = process.platform) => operatingSystem === "darwin" || (id !== "kimi-code" && id !== "kimi-work" && id !== "workbuddy");

package/dist/managed-skill-baseline.js

@@ -0,0 +1,35 @@
+// Public CLI 1.0.0 skill templates from reviewed commit 74530387. These pins
+// authorize only exact per-AI rendering after the complete old bundle verifies;
+// installation receipts, directory names and same-name files are never proof.
+export const LEGACY_MANAGED_SKILLS = [
+    {
+        "name": "caotang-context",
+        "description": "每个新对话第一件工作前，即使未提草堂也主动短读一次；闲聊和纯问答不读，接入同意门优先。",
+        "sha256": "e698b74c7fc0e81ae5155a842e5bcc026c0383cb528dac66ef4ee869703e89b1"
+    },
+    {
+        "name": "caotang-save-knowledge",
+        "description": "仅在要写入一间草堂私有知识、来源或长势时加载；确认内容再写，公开须本人网页确认。",
+        "sha256": "5c10105f96691697d7640e0c1e7a9ad5e8b79250dadc0c8d126e5538609391eb"
+    },
+    {
+        "name": "caotang-project-progress",
+        "description": "用户要记录一间草堂项目进展时，确认后保存私有进展，并按需局部更新认知摘要或阶段；项目公开须申请并由本人网页确认。",
+        "sha256": "bbece00f3f69fddb8ef57c12a4d84576238c962ae1526367cecdc102ac0cf409"
+    },
+    {
+        "name": "caotang-search",
+        "description": "用户询问一间草堂以前记录的项目、进展或知识时，先按词或时间检索，需要全文才读详情，并说明实际查询范围和权限缺口。",
+        "sha256": "d1feb8c82f841a0baa3fc4e70085d5eb90d0d7e35fdb08d3e3d0fd0d3bae967a"
+    },
+    {
+        "name": "caotang-workday",
+        "description": "仅在完成重要工作或收工时，整理一间草堂进展和下一步，先确认再保存；不承担开工。",
+        "sha256": "e6673787c66472fb58799b75da85894594da7c7da9a3b110d250a1166b1a358f"
+    },
+    {
+        "name": "caotang-first-connect",
+        "description": "一间草堂接入对话按入口首次安装和账号状态分流：有内容或未知先问一次再读，空账号只拟私有条目，同意才写；重复接入不问不读。",
+        "sha256": "47202fb64c5a9cd06ad06740be7f1ba1734400439bbb125c3138a0239b1bbd53"
+    }
+];

package/dist/missing-sections.js

@@ -4,6 +4,7 @@ const knownSections = {
     daily_knowledge: { capability: "read_knowledge", label: "日汇总中的知识新增与长势" },
     search_projects: { capability: "read_projects", label: "搜索中的项目与进展" },
     search_knowledge: { capability: "read_knowledge", label: "搜索中的知识" },
+    search_schedule_items: { capability: "read_workbench", label: "搜索中的待办" },
     workbench: { capability: "read_workbench", label: "工作台" },
     briefing: { capability: "read_notifications", label: "简报" },
     knowledge: { capability: "read_knowledge", label: "知识内容" },

package/dist/onboarding.js

@@ -1,10 +1,8 @@
 import { hostname } from "node:os";
-import { resolveCredential } from "./auth.js";
-import { verifiedHabit } from "./habit-wire.js";
 import { connectionCopy } from "./connection-copy.js";
 export const platformNames = {
     "claude-code": "Claude Code", codex: "Codex", openclaw: "OpenClaw",
-    "kimi-code": "Kimi Code", "kimi-work": "Kimi 工作模式", workbuddy: "WorkBuddy",
+    "kimi-code": "Kimi Code", "kimi-work": "Kimi 工作模式", workbuddy: "WorkBuddy", generic: "通用技能目录",
 };
 export function defaultConnectionNames(platforms, computerName = hostname(), agentName) {
     if (agentName !== undefined)
@@ -17,22 +15,8 @@ export function defaultConnectionNames(platforms, computerName = hostname(), age
         && !/^(?:[a-f\d-]{12,}|ip-\d|localhost$|runner|docker|container|sandbox|codespace|pod-)/i.test(name);
     return { clientName, deviceName: reliable ? `${clientName} · ${name}` : clientName };
 }
-export async function inspectAccountState(auth, owner) {
-    if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(owner))
-        return "unknown";
-    try {
-        const credential = await resolveCredential(auth);
-        const result = await auth.api.request("/api/v1/agent/m1/habit/start", { method: "GET", token: credential.token, signal: auth.signal });
-        if (result.status !== 200)
-            return "unknown";
-        const body = verifiedHabit(result.body, true);
-        if (body?.owner_id !== owner)
-            return "unknown";
-        return body.account_empty === true ? "empty" : body.account_empty === false ? "has_content" : "unknown";
-    }
-    catch {
-        return "unknown";
-    }
+export async function inspectAccountState(_auth, _owner) {
+    return "unknown";
 }
 export function onboardingMessage(newlyConnected, state, scope) {
     const action = newlyConnected.length === 0 ? "none" : state === "empty" ? "introduce" : "ask_once";
@@ -43,6 +27,6 @@ export function onboardingMessage(newlyConnected, state, scope) {
         account_state: state,
         onboarding: { action, newly_connected_platforms: newlyConnected },
         user_message: message,
-        skill_activation: newlyConnected.map(platform => ({ platform, message: platform === "codex" || platform === "claude-code" ? "新对话可以加载本次安装的技能。" : "如果看不到技能，请开新对话或重启应用；本次没有自动重启。" })),
+        skill_activation: newlyConnected.map(platform => ({ platform, message: "技能安装不代表当前 AI 已取得说明正文；请按宿主支持的方式加载，或运行 caotang guide 获取公共说明。" })),
     };
 }

package/dist/output.js

@@ -1,8 +1,10 @@
+import { workContextHuman } from "./work-context-human.js";
 import { asRecord, CliError } from "./errors.js";
 import { formatMissingSections } from "./missing-sections.js";
 import { projectedWriteCompleted } from "./write-permissions.js";
 import { formatSearchWarnings } from "./query-search.js";
 import { formatDailyNotice } from "./query-daily.js";
+import { calendarStartNotice } from "./habit-wire.js";
 import { createDraftNotice } from "./create-bundle.js";
 const sensitiveKey = /^(token|access_token|token_value|token_hash|device_code|upload_nonce|upload_url|required_headers|authorization|cookie|set-cookie|x-opc-upload-token)$/i;
 export function redact(value, secrets, depth = 0) {
@@ -23,6 +25,9 @@ export function redact(value, secrets, depth = 0) {
 }
 export function renderResult(result, human, secrets) {
     const data = redact({ http_status: result.status, data: result.body, ...(result.operationAudit?.length ? { operation_audit: result.operationAudit } : {}) }, secrets);
+    const summary = human ? workContextHuman(asRecord(data)?.data) : undefined;
+    if (summary !== undefined)
+        return summary + "\n";
     const missing = human ? formatMissingSections(asRecord(data)?.data) : "";
     const writeNotice = human && projectedWriteCompleted(result) ? "写入已完成；以下内容因读取权限未开启而没有返回，不是写入失败。\n" : "";
     const body = asRecord(result.body);
@@ -32,8 +37,9 @@ export function renderResult(result, human, secrets) {
     const warningNotice = human ? formatSearchWarnings(asRecord(data)?.data) : "";
     const dailyNotice = human ? formatDailyNotice(asRecord(data)?.data) : "";
     const draftNotice = human && [200, 201].includes(result.status) ? createDraftNotice(asRecord(data)?.data) : "";
+    const startNotice = human ? calendarStartNotice(asRecord(data)?.data) : "";
     const replayNotice = human && [200, 201].includes(result.status) && body?.idempotency_replayed === true ? "这是已有创建请求的回放结果，本次没有重新创建。\n" : "";
-    return `${pendingNotice}${replayNotice}${writeNotice}${missing}${warningNotice}${dailyNotice}${draftNotice}${JSON.stringify(data, null, human ? 2 : undefined)}\n`;
+    return `${pendingNotice}${replayNotice}${writeNotice}${startNotice ? startNotice + "\n" : ""}${missing}${warningNotice}${dailyNotice}${draftNotice}${JSON.stringify(data, null, human ? 2 : undefined)}\n`;
 }
 // Only coherent transport/receipt evidence classifies the submitted write;
 // neither a drafted audit log nor a moderation-pending 202 means unknown.

package/dist/platforms.js

@@ -2,6 +2,8 @@ import { constants } from "node:fs";
 import { access, lstat, readdir, realpath, stat } from "node:fs/promises";
 import { delimiter, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { asRecord, CliError } from "./errors.js";
+import { OwnedTree } from "./installation.js";
+import { PLATFORM_IDS, platformSupported } from "./local-types.js";
 const unsafe = () => new CliError("platform_path_unsafe", "平台目录未通过安全检查。", "请使用用户目录内的绝对路径，并检查目录和符号链接；不要提供目录中的配置内容。");
 const metadataError = (error) => {
     const code = asRecord(error)?.code;
@@ -87,6 +89,69 @@ async function skillDirectory(home, canonicalHome, root) {
     }
     return target;
 }
+// An explicit parent directory is a target, never a request to scan a host or
+// append another "skills" component. Current managed writes retain HOME's fence.
+export async function explicitSkillsTarget(options) {
+    const failure = () => new CliError("platform_path_unsafe", "通用技能目录未通过安全检查。", "当前受管安装仅支持本人用户目录内的真实绝对路径；共享或远程位置可先离线导出技能ZIP，再按宿主正式入口导入，不会放宽属主或链接保护。", 2);
+    if (!absolute(options.homeDir) || !absolute(options.skillsDirectory))
+        throw failure();
+    const home = resolve(options.homeDir), path = resolve(options.skillsDirectory);
+    if (path === home || !within(home, path))
+        throw failure();
+    try {
+        await new OwnedTree(home).directory(path, false, async () => true);
+    }
+    catch {
+        throw failure();
+    }
+    return { id: "generic", detected: true, evidence: "explicit", skillDirectory: path };
+}
+function configuredSkillRoot(home, env, id) {
+    switch (id) {
+        case "claude-code": return env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
+        case "codex": return join(home, ".agents");
+        case "openclaw": return env.OPENCLAW_STATE_DIR ?? (env.OPENCLAW_HOME === undefined ? join(home, ".openclaw") : (() => {
+            if (!absolute(env.OPENCLAW_HOME) || !within(home, resolve(env.OPENCLAW_HOME)))
+                throw unsafe();
+            return join(env.OPENCLAW_HOME, ".openclaw");
+        })());
+        case "kimi-code": return env.KIMI_CODE_HOME ?? join(home, ".kimi-code");
+        case "kimi-work": return join(home, "Library/Application Support/kimi-desktop/daimon-share/daimon");
+        case "workbuddy": return join(home, ".workbuddy");
+    }
+}
+// Bounded skill-location discovery only. No PATH, application bundle, client
+// executable, configuration contents or arbitrary HOME traversal is involved.
+export async function knownSkillTargets(options) {
+    if (!absolute(options.homeDir))
+        throw unsafe();
+    const home = resolve(options.homeDir);
+    let canonicalHome;
+    try {
+        canonicalHome = await realpath(home);
+        if (!(await stat(home)).isDirectory())
+            throw unsafe();
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw metadataError(error);
+    }
+    const targets = [];
+    for (const id of PLATFORM_IDS)
+        if (platformSupported(id, options.operatingSystem)) {
+            try {
+                targets.push({ id, detected: false, evidence: "none", skillDirectory: await skillDirectory(home, canonicalHome, configuredSkillRoot(home, options.env, id)) });
+            }
+            catch (error) {
+                // Only optional, bounded discovery isolates a candidate. Explicit or
+                // recorded targets are checked by their original strict path instead.
+                if (!options.skipInvalidCandidates)
+                    throw error;
+            }
+        }
+    return targets;
+}
 async function claudeDesktop(home) {
     const root = join(home, "Library", "Application Support", "Claude", "claude-code");
     for (const version of await directories(root)) {
@@ -122,15 +187,7 @@ export async function detectPlatforms(options) {
         throw unsafe();
     const selected = (id) => options.platformIds === undefined || options.platformIds.includes(id);
     const targets = [];
-    const candidates = [
-        { id: "claude-code", root: () => env.CLAUDE_CONFIG_DIR ?? join(home, ".claude") },
-        { id: "codex", root: () => join(home, ".agents") },
-        { id: "openclaw", root: () => env.OPENCLAW_STATE_DIR ?? (env.OPENCLAW_HOME === undefined ? join(home, ".openclaw") : (() => {
-                if (!absolute(env.OPENCLAW_HOME) || !within(home, resolve(env.OPENCLAW_HOME)))
-                    throw unsafe();
-                return join(env.OPENCLAW_HOME, ".openclaw");
-            })()) },
-    ];
+    const candidates = ["claude-code", "codex", "openclaw"].map(id => ({ id, root: () => configuredSkillRoot(home, env, id) }));
     for (const candidate of candidates) {
         if (selected(candidate.id))
             targets.push({ id: candidate.id, detected: false, evidence: "none", skillDirectory: await skillDirectory(home, canonicalHome, candidate.root()) });
@@ -167,9 +224,9 @@ export async function detectPlatforms(options) {
         // Do not inspect an unselected new platform's personal paths. Without a
         // selector, only a verified program makes its skill root relevant.
         for (const [id, app, binary, rootPath, command] of [
-            ["kimi-code", "Kimi Code", "Kimi Code", env.KIMI_CODE_HOME ?? join(home, ".kimi-code"), "kimi"],
-            ["kimi-work", "Kimi", "Kimi", join(home, "Library/Application Support/kimi-desktop/daimon-share/daimon"), null],
-            ["workbuddy", "WorkBuddy", "Electron", join(home, ".workbuddy"), null],
+            ["kimi-code", "Kimi Code", "Kimi Code", configuredSkillRoot(home, env, "kimi-code"), "kimi"],
+            ["kimi-work", "Kimi", "Kimi", configuredSkillRoot(home, env, "kimi-work"), null],
+            ["workbuddy", "WorkBuddy", "Electron", configuredSkillRoot(home, env, "workbuddy"), null],
         ]) {
             if (!selected(id))
                 continue;