@yijiancaotang/cli 0.0.0-stage → 1.0.0

package/dist/installation.js

@@ -0,0 +1,491 @@
+import { constants, lstatSync, fstatSync, openSync, closeSync, readSync, writeFileSync, fsyncSync, fchmodSync, mkdirSync, readdirSync, rmdirSync } from "node:fs";
+import { access, lstat, stat, realpath, open, readdir } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { CliError, asRecord } from "./errors.js";
+import { PLATFORM_IDS, isPlatformId, platformSupported } from "./local-types.js";
+import { bindSkillAgent, completeSkillInventory } from "./skill-assets.js";
+import { acquireLocalLock } from "./local-lock.js";
+const same = (a, b) => a.dev === b.dev && a.ino === b.ino;
+const missing = (error) => asRecord(error)?.code === "ENOENT";
+const unsafe = () => new CliError("installation_unsafe", "本地安装位置未通过安全检查。", "请人工检查属主、权限、符号链接与目标目录；不要自动删除、覆盖或修改凭据。");
+const permissionDenied = (path) => new CliError("installation_permission_denied", "没有权限访问本地安装目标目录。", "请由本人核对详情中目标目录的访问权限；不要自动提权或放宽权限。", 4, { target_directory: path });
+const conflict = () => new CliError("installation_conflict", "已有命令行文件与当前候选不一致。", "保留已有文件，先人工核对安装来源；不要强制覆盖或删除。");
+const skillConflict = () => new CliError("skill_conflict", "已有同名技能与当前候选不一致。", "保留原技能，人工核对冲突；不要覆盖个人修改。");
+const sourceInvalid = () => new CliError("installation_source_invalid", "当前命令行构建或技能资源不完整。", "使用维护者提供的完整且已审核的构建，不要运行不明安装脚本。", 7);
+const packageRoot = () => fileURLToPath(new URL("../", import.meta.url));
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const unchanged = (a, b) => same(a, b) && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+// No await or user callback while cwd is pinned: relative operations use the checked directory inode.
+function pinned(directory, action, failure = unsafe) {
+    const original = process.cwd();
+    try {
+        process.chdir(directory.path);
+        const current = lstatSync(".");
+        if (!current.isDirectory() || !same(current, directory.identity) || current.uid !== directory.identity.uid || (current.mode & 0o7777) !== (directory.identity.mode & 0o7777))
+            throw failure();
+        return action();
+    }
+    finally {
+        process.chdir(original);
+    }
+}
+function readDescriptor(fd, max) {
+    const bytes = Buffer.alloc(max + 1);
+    let length = 0;
+    while (length < bytes.length) {
+        const read = readSync(fd, bytes, length, bytes.length - length, length);
+        if (!read)
+            break;
+        length += read;
+    }
+    return bytes.subarray(0, length);
+}
+export class OwnedTree {
+    home;
+    uid;
+    constructor(home) { if (!isAbsolute(home) || typeof process.getuid !== "function")
+        throw unsafe(); this.home = resolve(home); this.uid = process.getuid(); }
+    within(path) {
+        const absolute = resolve(path), rel = relative(this.home, absolute);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            throw unsafe();
+        return absolute;
+    }
+    checkDirectory(info, path) {
+        if (!info.isDirectory() || info.uid !== this.uid || (info.mode & 0o022) !== 0)
+            throw unsafe();
+        const rel = relative(this.home, path);
+        if ((rel === ".caotang" || rel.startsWith(`.caotang${sep}`)) && (info.mode & 0o7777) !== 0o700)
+            throw unsafe();
+    }
+    async verify(directories) {
+        for (const directory of directories) {
+            const info = await lstat(directory.path);
+            this.checkDirectory(info, directory.path);
+            if (!same(info, directory.identity) || !same(await directory.handle.stat(), directory.identity))
+                throw unsafe();
+        }
+    }
+    async directory(path, create, action) {
+        const absolute = this.within(path), rel = relative(this.home, absolute), directories = [];
+        try {
+            let current = this.home;
+            for (const part of [null, ...(rel ? rel.split(sep) : [])]) {
+                if (part !== null)
+                    current = join(current, part);
+                let info;
+                try {
+                    info = await lstat(current);
+                }
+                catch (error) {
+                    if (!missing(error))
+                        throw error;
+                    if (current === this.home)
+                        throw unsafe();
+                    if (!create)
+                        return null;
+                    await this.verify(directories);
+                    const parent = directories.at(-1);
+                    if (!parent)
+                        throw unsafe();
+                    pinned(parent, () => {
+                        try {
+                            mkdirSync(part, { mode: 0o700 });
+                        }
+                        catch (created) {
+                            if (asRecord(created)?.code !== "EEXIST")
+                                throw created;
+                        }
+                    });
+                    info = await lstat(current);
+                }
+                this.checkDirectory(info, current);
+                if (await realpath(current) !== current)
+                    throw unsafe();
+                const handle = await open(current, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+                directories.push({ path: current, handle, identity: info });
+                if (!same(info, await handle.stat()))
+                    throw unsafe();
+            }
+            await this.verify(directories);
+            const value = await action(directories);
+            await this.verify(directories);
+            return value;
+        }
+        catch (error) {
+            if (!(error instanceof CliError) && ["EACCES", "EPERM"].includes(String(asRecord(error)?.code)))
+                throw permissionDenied(absolute);
+            throw error;
+        }
+        finally {
+            for (const directory of directories.reverse())
+                await directory.handle.close();
+        }
+    }
+    checkFile(info, max) {
+        if (!info.isFile() || info.uid !== this.uid || info.nlink !== 1 || (info.mode & 0o022) !== 0 || info.size > max)
+            throw unsafe();
+    }
+    readFile(name, max, executable = false) {
+        const check = (info) => { this.checkFile(info, max); if (executable && (info.mode & 0o100) === 0)
+            throw unsafe(); };
+        let before;
+        try {
+            before = lstatSync(name);
+        }
+        catch (error) {
+            if (missing(error))
+                return null;
+            throw error;
+        }
+        check(before);
+        const fd = openSync(name, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        try {
+            const opened = fstatSync(fd);
+            check(opened);
+            if (!unchanged(before, opened))
+                throw unsafe();
+            const bytes = readDescriptor(fd, max), after = fstatSync(fd), current = lstatSync(name);
+            check(after);
+            check(current);
+            if (bytes.length !== opened.size || !unchanged(opened, after) || !unchanged(after, current))
+                throw unsafe();
+            return bytes;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    async read(path, max = 1048576) {
+        return this.directory(dirname(path), false, async (directories) => {
+            return pinned(directories.at(-1), () => this.readFile(basename(path), max));
+        });
+    }
+    async list(path) {
+        return this.directory(path, false, async (directories) => pinned(directories.at(-1), () => readdirSync(".").sort()));
+    }
+    async createDirectory(path) {
+        return this.directory(dirname(path), true, async (directories) => {
+            await this.verify(directories);
+            return pinned(directories.at(-1), () => {
+                try {
+                    mkdirSync(basename(path), { mode: 0o700 });
+                }
+                catch (error) {
+                    if (asRecord(error)?.code === "EEXIST")
+                        return null;
+                    throw error;
+                }
+                const result = lstatSync(basename(path));
+                this.checkDirectory(result, path);
+                return result;
+            });
+        });
+    }
+    async writeNew(path, bytes, mode) {
+        const result = await this.directory(dirname(path), true, async (directories) => {
+            return pinned(directories.at(-1), () => {
+                const name = basename(path);
+                let fd;
+                try {
+                    fd = openSync(name, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0);
+                }
+                catch (error) {
+                    if (asRecord(error)?.code !== "EEXIST")
+                        throw error;
+                    if (!this.readFile(name, 1048576, (mode & 0o100) !== 0)?.equals(bytes))
+                        throw conflict();
+                    return false;
+                }
+                try {
+                    const initial = fstatSync(fd);
+                    this.checkFile(initial, bytes.length);
+                    if (initial.size !== 0 || (initial.mode & 0o7777) !== 0)
+                        throw unsafe();
+                    writeFileSync(fd, bytes);
+                    fsyncSync(fd);
+                    const written = fstatSync(fd), current = lstatSync(name);
+                    this.checkFile(written, bytes.length);
+                    this.checkFile(current, bytes.length);
+                    if (!same(initial, written) || !unchanged(written, current) || written.size !== bytes.length || !readDescriptor(fd, bytes.length).equals(bytes))
+                        throw unsafe();
+                    fchmodSync(fd, mode);
+                    fsyncSync(fd);
+                    const final = fstatSync(fd), published = lstatSync(name);
+                    this.checkFile(final, bytes.length);
+                    this.checkFile(published, bytes.length);
+                    if (!same(initial, final) || !unchanged(final, published) || (final.mode & 0o7777) !== mode || final.size !== bytes.length || final.mtimeMs !== written.mtimeMs
+                        || !readDescriptor(fd, bytes.length).equals(bytes) || !unchanged(final, fstatSync(fd)) || !unchanged(final, lstatSync(name)))
+                        throw unsafe();
+                    return true;
+                }
+                catch (error) {
+                    // Only this newly-created inode may be demoted; the pathname may now name somebody else's file.
+                    try {
+                        fchmodSync(fd, 0);
+                        fsyncSync(fd);
+                    }
+                    catch { /* Filesystem failure can prevent rollback; keep the installation failed. */ }
+                    throw error;
+                }
+                finally {
+                    closeSync(fd);
+                }
+            });
+        });
+        return result === true;
+    }
+    async removeDirectory(path, expected) {
+        await this.directory(dirname(path), false, async (directories) => {
+            pinned(directories.at(-1), () => {
+                const info = lstatSync(basename(path));
+                this.checkDirectory(info, path);
+                if (!same(info, expected))
+                    throw unsafe();
+                rmdirSync(basename(path));
+            });
+        });
+    }
+}
+async function readSource(path, max = 1048576) {
+    try {
+        const parent = dirname(path), identity = await lstat(parent);
+        if (!identity.isDirectory() || await realpath(parent) !== parent)
+            throw sourceInvalid();
+        return pinned({ path: parent, identity }, () => {
+            const valid = (info) => { if (!info.isFile() || info.nlink !== 1 || info.size < 1 || info.size > max)
+                throw sourceInvalid(); };
+            const name = basename(path), before = lstatSync(name);
+            valid(before);
+            const fd = openSync(name, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const opened = fstatSync(fd);
+                valid(opened);
+                if (!unchanged(before, opened))
+                    throw sourceInvalid();
+                const bytes = readDescriptor(fd, max), after = fstatSync(fd), current = lstatSync(name);
+                valid(after);
+                valid(current);
+                if (bytes.length !== opened.size || !unchanged(opened, after) || !unchanged(after, current))
+                    throw sourceInvalid();
+                return bytes;
+            }
+            finally {
+                closeSync(fd);
+            }
+        }, sourceInvalid);
+    }
+    catch {
+        throw sourceInvalid();
+    }
+}
+async function bundle(ctx, tree) {
+    if (!completeSkillInventory(ctx.assets.map(asset => asset.name)) || ctx.assets.some(asset => hash(asset.content) !== asset.sha256 || !asset.content || Buffer.byteLength(asset.content) > 65536))
+        throw sourceInvalid();
+    const source = resolve(ctx.packageRoot ?? packageRoot());
+    if (await realpath(source) !== source)
+        throw sourceInvalid();
+    const info = asRecord(JSON.parse((await readSource(join(source, "package.json"), 32768)).toString("utf8")));
+    if (!info || info.name !== "@yijiancaotang/cli" || (info.private !== true && asRecord(info.publishConfig)?.access !== "public") || typeof info.version !== "string" || !/^\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?$/i.test(info.version))
+        throw sourceInvalid();
+    const runtimeManifest = { name: info.name, version: info.version, private: true, type: "module", engines: { node: ">=20" }, bin: { caotang: "bin/caotang.cjs" } };
+    const files = [{ path: "package.json", bytes: Buffer.from(JSON.stringify(runtimeManifest)), mode: 0o600 }, { path: "bin/caotang.cjs", bytes: await readSource(join(source, "bin", "caotang.cjs")), mode: 0o700 }];
+    const dist = join(source, "dist");
+    if (!(await lstat(dist)).isDirectory() || await realpath(dist) !== dist)
+        throw sourceInvalid();
+    const modules = (await readdir(dist)).filter(name => name.endsWith(".js")).sort();
+    // The shipped runtime has one nested generated dependency. Keep the 64-file
+    // JS limit across both categories; do not recursively trust dist subtrees.
+    if (!modules.includes("cli.js") || modules.length + 1 > 64)
+        throw sourceInvalid();
+    for (const name of modules) {
+        if (!/^[a-z][a-z0-9-]*\.js$/.test(name))
+            throw sourceInvalid();
+        files.push({ path: `dist/${name}`, bytes: await readSource(join(dist, name)), mode: 0o600 });
+    }
+    files.push({ path: "dist/generated/knowledge-growth.js", bytes: await readSource(join(dist, "generated", "knowledge-growth.js")), mode: 0o600 });
+    files.push({ path: "skills/manifest.json", bytes: Buffer.from(JSON.stringify({ formatVersion: 1, skills: ctx.assets.map(({ name, description }) => ({ name, description })) })), mode: 0o600 });
+    for (const asset of ctx.assets)
+        files.push({ path: `skills/${asset.name}/SKILL.md`, bytes: Buffer.from(asset.content), mode: 0o600 });
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    if (files.reduce((total, file) => total + file.bytes.length, 0) > 5242880)
+        throw sourceInvalid();
+    const digest = createHash("sha256");
+    for (const file of files)
+        digest.update(`${file.path}\0${file.mode}\0${file.bytes.length}\0`).update(file.bytes);
+    const sha = digest.digest("hex"), directory = join(tree.home, ".caotang", "cli", "releases", sha), command = join(tree.home, ".local", "bin", "caotang");
+    const shim = Buffer.from(`#!/usr/bin/env node\n// caotang managed command v1\nimport(${JSON.stringify(pathToFileURL(join(directory, "bin", "caotang.cjs")).href)}).catch(()=>{process.stderr.write(JSON.stringify({code:"cli_unavailable",message:"本地命令行暂不可用。",next_action:"请人工核对本地安装，不要重复业务写入。"})+"\\n");process.exitCode=7;});\n`);
+    return { files, sha, directory, command, shim, version: info.version };
+}
+function validateTargets(ctx, tree) {
+    if (ctx.targets.length > PLATFORM_IDS.length || new Set(ctx.targets.map(target => target.id)).size !== ctx.targets.length)
+        throw unsafe();
+    for (const target of ctx.targets) {
+        if (!isPlatformId(target.id) || !platformSupported(target.id, ctx.operatingSystem) || !isAbsolute(target.skillDirectory) || tree.within(target.skillDirectory) === tree.home)
+            throw unsafe();
+    }
+}
+async function skillState(tree, target, asset) {
+    const dir = join(target.skillDirectory, asset.name), entries = await tree.list(dir);
+    if (entries === null || entries.length === 0)
+        return "missing";
+    if (entries.length !== 1 || entries[0] !== "SKILL.md")
+        return "modified";
+    const bytes = await tree.read(join(dir, "SKILL.md"), 65536);
+    return bytes && hash(bytes) === asset.sha256 ? "installed" : "modified";
+}
+async function bundleState(tree, value) {
+    if (await tree.list(value.directory) === null)
+        return "missing";
+    const expected = new Set(value.files.map(file => file.path));
+    async function walk(dir, prefix = "") {
+        const entries = await tree.list(dir);
+        if (!entries)
+            return false;
+        for (const name of entries) {
+            const path = prefix + name;
+            if (value.files.some(file => file.path.startsWith(path + "/"))) {
+                if (!await walk(join(dir, name), path + "/"))
+                    return false;
+            }
+            else if (!expected.has(path))
+                return false;
+        }
+        return true;
+    }
+    if (!await walk(value.directory))
+        return "modified";
+    for (const file of value.files) {
+        const bytes = await tree.read(join(value.directory, file.path));
+        if (!bytes?.equals(file.bytes))
+            return "modified";
+    }
+    return "installed";
+}
+async function onPath(command, env) {
+    for (const entry of (env.PATH ?? "").split(delimiter)) {
+        if (!isAbsolute(entry))
+            continue;
+        try {
+            if (await realpath(join(entry, "caotang")) === command && ((await stat(command)).mode & 0o100) !== 0) {
+                await access(command, constants.X_OK);
+                return true;
+            }
+        }
+        catch { }
+    }
+    return false;
+}
+export async function installLocal(ctx) {
+    const tree = new OwnedTree(ctx.homeDir), changed = [];
+    let changesPossible = false;
+    const newlyInstalledPlatforms = [];
+    try {
+        validateTargets(ctx, tree);
+        if (!ctx.targets.length && !ctx.agentName)
+            throw new CliError("no_supported_platform", "未识别到支持的AI客户端。", "核对Claude Code、Codex、OpenClaw，或macOS上的Kimi Code、Kimi工作模式、WorkBuddy后再接入；不会自动安装客户端。");
+        const value = await bundle(ctx, tree);
+        await tree.directory(tree.home, false, async () => { });
+        for (const target of ctx.targets)
+            for (const asset of ctx.assets)
+                if (await skillState(tree, target, bindSkillAgent(asset, ctx.agentName)) === "modified")
+                    throw skillConflict();
+        const existingCommand = await tree.read(value.command);
+        if (existingCommand && !existingCommand.equals(value.shim))
+            throw conflict();
+        if (existingCommand && ((await lstat(value.command)).mode & 0o100) === 0)
+            throw unsafe();
+        if (await bundleState(tree, value) === "modified")
+            throw conflict();
+        const lockPath = join(tree.home, ".caotang", ".setup.lock");
+        changesPossible = true;
+        const release = await tree.directory(dirname(lockPath), true, async (directories) => acquireLocalLock(lockPath, directories.at(-1), {
+            unsafe,
+            busy: () => new CliError("installation_busy", "另一项本地安装正在进行或锁状态无法确认。", "等待本地安装结束；状态不明时保留锁，由你人工核查，不自动删除。"),
+        }));
+        if (!release)
+            throw unsafe();
+        try {
+            const state = await bundleState(tree, value);
+            if (state === "modified")
+                throw conflict();
+            for (const target of ctx.targets) {
+                const statuses = await Promise.all(ctx.assets.map(asset => skillState(tree, target, bindSkillAgent(asset, ctx.agentName))));
+                if (statuses.includes("modified"))
+                    throw skillConflict();
+                if (statuses.every(status => status === "missing"))
+                    newlyInstalledPlatforms.push(target.id);
+            }
+            if (state === "missing") {
+                const created = await tree.createDirectory(value.directory);
+                if (!created)
+                    throw conflict();
+                changed.push("bundle");
+                for (const file of value.files)
+                    await tree.writeNew(join(value.directory, file.path), file.bytes, file.mode);
+                if (await bundleState(tree, value) !== "installed")
+                    throw conflict();
+            }
+            for (const target of ctx.targets)
+                for (const asset of ctx.assets) {
+                    if (await skillState(tree, target, bindSkillAgent(asset, ctx.agentName)) === "installed")
+                        continue;
+                    const dir = join(target.skillDirectory, asset.name), created = await tree.createDirectory(dir);
+                    if (!created && (await tree.list(dir))?.length !== 0)
+                        throw skillConflict();
+                    changed.push(`${target.id}:${asset.name}`);
+                    await tree.writeNew(join(dir, "SKILL.md"), Buffer.from(bindSkillAgent(asset, ctx.agentName).content), 0o600);
+                    if (await skillState(tree, target, bindSkillAgent(asset, ctx.agentName)) !== "installed")
+                        throw skillConflict();
+                }
+            if (await tree.writeNew(value.command, value.shim, 0o700))
+                changed.push("command");
+        }
+        finally {
+            release();
+        }
+        return { changed, bundleSha: value.sha, bundleDirectory: value.directory, newlyInstalledPlatforms };
+    }
+    catch (error) {
+        const safe = error instanceof CliError ? error
+            : ["EPERM", "EACCES"].includes(String(asRecord(error)?.code)) ? permissionDenied(join(tree.home, ".caotang")) : unsafe();
+        throw new CliError(safe.code, safe.message, safe.nextAction, safe.exitCode, { ...safe.details, local_changes_possible: changesPossible, local_changes: changed });
+    }
+}
+export async function inspectLocalInstallation(ctx) {
+    const tree = new OwnedTree(ctx.homeDir);
+    validateTargets(ctx, tree);
+    const value = await bundle(ctx, tree), issues = [];
+    const issue = (code, message, next_action) => issues.push({ code, message, next_action });
+    let installed = false;
+    const current = await tree.read(value.command);
+    if (!current)
+        issue("command_not_installed", "稳定命令行尚未安装。", "运行 setup 完成本地安装。");
+    else if (!current.equals(value.shim) || await bundleState(tree, value) !== "installed" || ((await lstat(value.command)).mode & 0o100) === 0)
+        issue("command_modified", "已有命令行与当前候选不一致。", "保留现有文件并人工核对，不自动覆盖。");
+    else
+        installed = true;
+    const on_path = installed && await onPath(value.command, ctx.env);
+    if (!ctx.targets.some(target => target.detected))
+        issue("no_supported_platform", "尚未识别到支持的AI客户端。", "核对Claude Code、Codex、OpenClaw，或macOS上的Kimi Code、Kimi工作模式、WorkBuddy程序入口，再运行doctor。");
+    const platforms = [];
+    for (const target of ctx.targets) {
+        const skills = [];
+        for (const asset of ctx.assets) {
+            let status;
+            try {
+                status = await skillState(tree, target, bindSkillAgent(asset, ctx.agentName));
+            }
+            catch {
+                status = "unsafe";
+            }
+            skills.push({ name: asset.name, status });
+            if (target.detected && status !== "installed")
+                issue(status === "missing" ? "skill_missing" : status === "modified" ? "skill_modified" : "skill_unsafe", "本地技能缺失、已修改或不满足安全要求。", status === "missing" ? `运行 setup --platform ${target.id} 安装缺失技能。` : "保留现有技能并人工核对，不自动覆盖或修复。");
+        }
+        platforms.push({ id: target.id, detected: target.detected, skill_directory: target.skillDirectory, skills });
+    }
+    return { command: { installed, on_path, version: value.version, ...(installed ? { executable_path: value.command } : {}) }, platforms, issues };
+}

package/dist/knowledge-growth.js

@@ -0,0 +1,85 @@
+import { knowledgeGrowthMetadata } from "./generated/knowledge-growth.js";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+// Presentation only: the API remains the source of enums and read projections.
+// No recursive status search, fallback enum, request, or permission expansion.
+function readable(row, parent, event = false) {
+    for (const scope of [parent, row]) {
+        const value = scope.missing_sections;
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value))
+            return false;
+        for (const item of value) {
+            const missing = record(item);
+            if (!missing)
+                return false;
+            const capability = missing.required_capability ?? missing.capability;
+            if (capability === "read_knowledge")
+                return false;
+            // Daily items are already visibility-filtered; an aggregate draft gap
+            // describes excluded records, not the readable event returned here.
+            if (capability === "read_drafts" && row.publication_status !== "published" && !(event && scope === parent))
+                return false;
+        }
+    }
+    return true;
+}
+function card(value, parent) {
+    const row = record(value);
+    if (!row || typeof row.id !== "string" || !row.id || !readable(row, parent))
+        return value;
+    const growth = knowledgeGrowthMetadata(row.internalization_status);
+    return growth ? { ...row, growth } : value;
+}
+function field(body, key, list = false) {
+    const value = body[key];
+    const mapped = list && Array.isArray(value) ? value.map(row => card(row, body)) : list ? value : card(value, body);
+    return mapped === value || Array.isArray(value) && Array.isArray(mapped) && value.every((row, i) => row === mapped[i])
+        ? body : { ...body, [key]: mapped };
+}
+export function withKnowledgeGrowth(path, value, status) {
+    const body = record(value);
+    if (!body || ![200, 201].includes(status))
+        return value;
+    const route = path.split("?")[0].replace(/^\/api\/v1\/agent/, "");
+    if (route === "/m1/knowledge")
+        return field(body, "items", true);
+    if (/^\/m1\/knowledge\/[^/]+$/.test(route))
+        return field(body, "card");
+    if (/^\/m1\/projects\/[^/]+$/.test(route))
+        return field(body, "knowledge", true);
+    if (route === "/m1/workbench")
+        return field(body, "recent_knowledge", true);
+    if (route === "/m1/activity/daily" && Array.isArray(body.items)) {
+        let changed = false;
+        const items = body.items.map(value => {
+            const row = record(value);
+            if (!row || row.kind !== "knowledge_growth" || typeof row.id !== "string" || !row.id
+                || typeof row.knowledge_card_id !== "string" || !row.knowledge_card_id || !readable(row, body, true))
+                return value;
+            const from = knowledgeGrowthMetadata(row.from_status), to = knowledgeGrowthMetadata(row.to_status);
+            if (!from || !to)
+                return value;
+            changed = true;
+            return { ...row, from_growth: from, to_growth: to };
+        });
+        return changed ? { ...body, items } : value;
+    }
+    if (/^\/m2\/knowledge-cards(?:\/[^/]+(?:\/project-link(?:\/[^/]+)?)?)?$/.test(route)
+        || /^\/m2\/knowledge-cards\/[^/]+\/stage$/.test(route)) {
+        if (body.original_receipt === true || body.write_status !== undefined && body.write_status !== "succeeded"
+            || body.moderation_pending === true || body.write_pending === true || body.moderation_status === "pending_review"
+            || ["failed", "rejected", "unknown", "drafted"].includes(String(body.action_status))
+            || ["failed", "rejected", "unknown", "drafted"].includes(String(record(body.action_log)?.action_status)))
+            return value;
+        if (route.endsWith("/stage")) {
+            const detail = record(body.knowledge);
+            if (!detail || !readable(detail, body))
+                return value;
+            const knowledge = field(detail, "card");
+            return knowledge === detail ? value : { ...body, knowledge };
+        }
+        return field(body, "knowledge_card");
+    }
+    return value;
+}