@zokizuan/satori-mcp 4.3.1 → 4.4.1

package/README.md

@@ -17,7 +17,7 @@ MCP server for Satori — agent-safe semantic code search and indexing.
 - Zod-first tool schemas converted to MCP JSON Schema for `ListTools`
 - Auto-generated tool docs from live tool schemas
 - `read_file` line-range retrieval with default large-file truncation guard and optional `mode="annotated"` metadata envelope
-- Optional proactive sync watcher mode (debounced filesystem events)
+- Optional proactive sync watcher mode (debounced filesystem events for explicitly touched roots in the current session)
 - Index-time AST scope breadcrumbs (TS/JS/Python) rendered in search output as `🧬 Scope`
 - Fingerprint schema `dense_v3`/`hybrid_v3` with hard gate for all pre-v3 indexes
 
@@ -46,6 +46,7 @@ Tool surface is hard-broken to 6 tools. This keeps routing explicit while exposi
 
 - Enabled by default. Set `MCP_ENABLE_WATCHER=false` to disable
 - Debounce window via `MCP_WATCH_DEBOUNCE_MS` (default `5000`)
+- Watchers are session-scoped: startup does not watch every indexed codebase, only roots touched by successful index/search/navigation/read flows in the current session
 - Watch events reuse the same incremental sync pipeline (`reindexByChange`)
 - Ignore control files (`.satoriignore`, root `.gitignore`) trigger no-reindex reconciliation:
   - delete indexed paths now ignored by active rules
@@ -156,7 +157,7 @@ No parameters.
   "mcpServers": {
     "satori": {
       "command": "npx",
-      "args": ["-y", "@zokizuan/satori-mcp@latest"],
+      "args": ["-y", "@zokizuan/satori-mcp@4.4.1"],
       "timeout": 180000,
       "env": {
         "EMBEDDING_PROVIDER": "VoyageAI",
@@ -177,7 +178,7 @@ No parameters.
 ```toml
 [mcp_servers.satori]
 command = "npx"
-args = ["-y", "@zokizuan/satori-mcp@latest"]
+args = ["-y", "@zokizuan/satori-mcp@4.4.1"]
 startup_timeout_ms = 180000
 env = { EMBEDDING_PROVIDER = "VoyageAI", EMBEDDING_MODEL = "voyage-4-large", EMBEDDING_OUTPUT_DIMENSION = "1024", VOYAGEAI_API_KEY = "your-api-key", VOYAGEAI_RERANKER_MODEL = "rerank-2.5", MILVUS_ADDRESS = "your-milvus-endpoint", MILVUS_TOKEN = "your-milvus-token" }
 ```
@@ -189,7 +190,7 @@ env = { EMBEDDING_PROVIDER = "VoyageAI", EMBEDDING_MODEL = "voyage-4-large", EMB
   "mcpServers": {
     "satori": {
       "command": "node",
-      "args": ["/absolute/path/to/claude-context/packages/mcp/dist/index.js"],
+      "args": ["/absolute/path/to/satori/packages/mcp/dist/index.js"],
       "timeout": 180000,
       "env": {
         "EMBEDDING_PROVIDER": "VoyageAI",
@@ -213,9 +214,30 @@ Never commit real API keys/tokens into repo config files.
 pnpm --filter @zokizuan/satori-mcp start
 ```
 
-## Shell CLI (`satori-cli`)
+## Shell CLI (`@zokizuan/satori-cli`)
 
-`@zokizuan/satori-mcp` also ships a shell-first client binary that works without an MCP adapter.
+The shell-first installer/client now lives in a separate package: `@zokizuan/satori-cli`.
+
+### Install / Uninstall
+
+Supported installer targets in Phase 1:
+- `codex`
+- `claude`
+- `all`
+
+Examples:
+
+```bash
+npx -y @zokizuan/satori-cli@0.1.1 install --client codex
+npx -y @zokizuan/satori-cli@0.1.1 install --client claude
+npx -y @zokizuan/satori-cli@0.1.1 install --client all --dry-run
+npx -y @zokizuan/satori-cli@0.1.1 uninstall --client codex
+```
+
+Install and uninstall run before MCP session startup, only touch Satori-managed config, and copy/remove these packaged skills:
+- `satori-search`
+- `satori-navigation`
+- `satori-indexing`
 
 ### Commands
 
@@ -271,6 +293,8 @@ pnpm --filter @zokizuan/satori-mcp build
 pnpm --filter @zokizuan/satori-mcp typecheck
 pnpm --filter @zokizuan/satori-mcp test
 pnpm --filter @zokizuan/satori-mcp docs:check
+pnpm --filter @zokizuan/satori-cli build
+pnpm --filter @zokizuan/satori-cli test
 ```
 
 `build` automatically runs docs generation from tool schemas.

package/dist/cli/args.d.ts

@@ -19,6 +19,14 @@ export type ParsedCommand = {
     kind: "help";
 } | {
     kind: "version";
+} | {
+    kind: "install";
+    client: InstallClient;
+    dryRun: boolean;
+} | {
+    kind: "uninstall";
+    client: InstallClient;
+    dryRun: boolean;
 } | {
     kind: "tools-list";
 } | {
@@ -39,6 +47,7 @@ export interface ResolveRawArgsOptions {
     stdin?: NodeJS.ReadStream;
     stdinTimeoutMs: number;
 }
+export type InstallClient = "all" | "claude" | "codex";
 export declare function parseCliArgs(argv: string[]): ParsedCliInput;
 export declare function resolveRawArguments(rawArgsMode: RawArgsMode, options: ResolveRawArgsOptions): Promise<Record<string, unknown>>;
 export declare function parseWrapperArgumentsFromSchema(toolName: string, inputSchema: unknown, wrapperArgs: string[]): Record<string, unknown>;

package/dist/cli/args.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { CliError } from "./errors.js";
-const RESERVED_SUBCOMMANDS = new Set(["tools", "tool", "help", "version"]);
+const RESERVED_SUBCOMMANDS = new Set(["tools", "tool", "help", "version", "install", "uninstall"]);
 const PRIMITIVE_TYPES = new Set(["string", "number", "integer", "boolean"]);
 function parsePositiveInteger(value, flagName) {
     const parsed = Number.parseInt(value, 10);
@@ -109,6 +109,28 @@ function parseRawArgsMode(args) {
     }
     return { rawArgsMode, remaining };
 }
+function parseInstallCommand(kind, args) {
+    let client = "all";
+    let dryRun = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--client") {
+            const next = args[i + 1];
+            if (next !== "all" && next !== "claude" && next !== "codex") {
+                throw new CliError("E_USAGE", "--client must be one of: all, claude, codex.", 2);
+            }
+            client = next;
+            i += 1;
+            continue;
+        }
+        if (token === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        throw new CliError("E_USAGE", `Unknown arguments for ${kind}: ${args.slice(i).join(" ")}`, 2);
+    }
+    return { kind, client, dryRun };
+}
 export function parseCliArgs(argv) {
     const { globals, rest } = parseGlobalOptions(argv);
     if (rest.length === 0 || rest[0] === "help" || rest.includes("--help") || rest.includes("-h")) {
@@ -123,6 +145,18 @@ export function parseCliArgs(argv) {
             command: { kind: "version" }
         };
     }
+    if (rest[0] === "install") {
+        return {
+            globals,
+            command: parseInstallCommand("install", rest.slice(1))
+        };
+    }
+    if (rest[0] === "uninstall") {
+        return {
+            globals,
+            command: parseInstallCommand("uninstall", rest.slice(1))
+        };
+    }
     if (rest[0] === "tools") {
         if (rest.length === 2 && rest[1] === "list") {
             return {

package/dist/cli/client.js

@@ -39,6 +39,7 @@ export class CliMcpSession {
         return createTimeout(this.client.callTool({ name, arguments: args }), this.callTimeoutMs, "E_CALL_TIMEOUT", `Timed out after ${this.callTimeoutMs}ms while calling tools/call for '${name}'.`);
     }
     async close() {
+        const stderr = this.transport.stderr;
         try {
             await this.client.close();
         }
@@ -51,6 +52,7 @@ export class CliMcpSession {
         catch {
             // Best-effort close.
         }
+        stderr?.removeAllListeners("data");
     }
     logProtocolFailure(error) {
         if (error instanceof CliError) {
@@ -79,7 +81,7 @@ export async function connectCliMcpSession(options) {
     });
     const client = new Client({
         name: "satori-cli",
-        version: "1.1.0",
+        version: "1.1.1",
     });
     const session = new CliMcpSession(client, transport, options.callTimeoutMs, options.writeStderr);
     session.wireStderr();

package/dist/cli/index.d.ts

@@ -3,12 +3,28 @@ interface RunCliOptions {
     writeStdout?: (text: string) => void;
     writeStderr?: (text: string) => void;
     stdin?: NodeJS.ReadStream;
+    env?: NodeJS.ProcessEnv;
     serverCommand?: string;
     serverArgs?: string[];
     serverEnv?: Record<string, string>;
     startupTimeoutMs?: number;
     callTimeoutMs?: number;
     cwd?: string;
+    installabilityVerifier?: () => string | Promise<string>;
+    connectSession?: (options: {
+        command: string;
+        args: string[];
+        env: Record<string, string | undefined>;
+        cwd?: string;
+        startupTimeoutMs: number;
+        callTimeoutMs: number;
+        writeStderr: (text: string) => void;
+    }) => Promise<CliSession>;
+}
+interface CliSession {
+    listTools(): Promise<any>;
+    callTool(name: string, args: Record<string, unknown>): Promise<any>;
+    close(): Promise<void>;
 }
 export declare function runCli(argv: string[], options?: RunCliOptions): Promise<number>;
 export declare function isExecutedDirectlyForPaths(moduleUrl: string, entryPath: string | undefined): boolean;

package/dist/cli/index.js

@@ -6,6 +6,8 @@ import { parseCliArgs, parseWrapperArgumentsFromSchema, resolveRawArguments } fr
 import { connectCliMcpSession } from "./client.js";
 import { asCliError, CliError } from "./errors.js";
 import { emitError, emitJson, inferManageStatusState, parseStructuredEnvelope } from "./format.js";
+import { executeInstallCommand } from "./install.js";
+import { verifyManagedPackageInstallability } from "./package-installability.js";
 import { resolveServerEntryPath } from "./resolve-server-entry.js";
 const MANAGE_INDEX_MIN_POLL_TIMEOUT_MS = 10 * 60 * 1000;
 function firstText(result) {
@@ -42,6 +44,8 @@ function buildHelpPayload() {
     return {
         usage: "satori-cli <command>",
         commands: [
+            "install [--client all|codex|claude] [--dry-run]",
+            "uninstall [--client all|codex|claude] [--dry-run]",
             "tools list",
             "tool call <toolName> --args-json '<json>'",
             "tool call <toolName> --args-file <path>",
@@ -164,6 +168,7 @@ export async function runCli(argv, options = {}) {
         writeStdout: options.writeStdout || ((text) => process.stdout.write(text)),
         writeStderr: options.writeStderr || ((text) => process.stderr.write(text)),
     };
+    const effectiveEnv = options.env || process.env;
     let parsedFormat = "json";
     let parsedCommandKind = null;
     try {
@@ -190,11 +195,24 @@ export async function runCli(argv, options = {}) {
             }
             return 0;
         }
-        const session = await connectCliMcpSession({
+        if (parsed.command.kind === "install" || parsed.command.kind === "uninstall") {
+            if (parsed.command.kind === "install") {
+                await (options.installabilityVerifier || verifyManagedPackageInstallability)();
+            }
+            const result = executeInstallCommand(parsed.command, {
+                homeDir: effectiveEnv.HOME,
+            });
+            emitJson(writers, result);
+            if (parsed.globals.format === "text") {
+                writers.writeStderr(`satori-cli ${parsed.command.kind} completed for ${parsed.command.client}.\n`);
+            }
+            return 0;
+        }
+        const session = await (options.connectSession || connectCliMcpSession)({
             command: options.serverCommand || process.execPath,
             args: options.serverArgs || resolveDefaultServerArgs(),
             env: {
-                ...process.env,
+                ...effectiveEnv,
                 ...options.serverEnv,
                 SATORI_RUN_MODE: "cli",
             },

package/dist/cli/install.d.ts

@@ -0,0 +1,30 @@
+import type { InstallClient } from "./args.js";
+type ClientName = Exclude<InstallClient, "all">;
+export interface InstallCommandInput {
+    kind: "install" | "uninstall";
+    client: InstallClient;
+    dryRun: boolean;
+}
+export interface InstallCommandOptions {
+    homeDir?: string;
+    packageSpecifier?: string;
+    skillAssetRoot?: string;
+}
+export interface ClientInstallResult {
+    client: ClientName;
+    configPath: string;
+    skillsPath: string;
+    configChanged: boolean;
+    skillsChanged: boolean;
+    status: "updated" | "unchanged";
+    dryRun: boolean;
+}
+export interface InstallCommandResult {
+    action: "install" | "uninstall";
+    client: InstallClient;
+    dryRun: boolean;
+    results: ClientInstallResult[];
+}
+export declare function executeInstallCommand(command: InstallCommandInput, options?: InstallCommandOptions): InstallCommandResult;
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/install.js

@@ -0,0 +1,329 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CliError } from "./errors.js";
+const MANAGED_BLOCK_START = "# >>> satori-cli managed satori start >>>";
+const MANAGED_BLOCK_END = "# <<< satori-cli managed satori end <<<";
+const OWNED_SKILL_DIRS = ["satori-search", "satori-navigation", "satori-indexing"];
+const MANAGED_TIMEOUT_MS = 180000;
+function resolveDefaultSkillAssetRoot() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), "..", "..", "assets", "skills");
+}
+function resolveDefaultPackageSpecifier() {
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        const packagePath = path.resolve(path.dirname(currentFile), "..", "..", "package.json");
+        const parsed = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+        if (typeof parsed.name === "string" && typeof parsed.version === "string") {
+            return `${parsed.name}@${parsed.version}`;
+        }
+    }
+    catch {
+        // Fall through to hard failure below.
+    }
+    throw new CliError("E_USAGE", "Unable to resolve the installed Satori package version for CLI install.", 2);
+}
+function resolveClientTargets(homeDir) {
+    return [
+        {
+            client: "codex",
+            configPath: path.join(homeDir, ".codex", "config.toml"),
+            skillsPath: path.join(homeDir, ".codex", "skills"),
+        },
+        {
+            client: "claude",
+            configPath: path.join(homeDir, ".claude", "settings.json"),
+            skillsPath: path.join(homeDir, ".claude", "skills"),
+        },
+    ];
+}
+function selectTargets(homeDir, client) {
+    const targets = resolveClientTargets(homeDir);
+    if (client === "all") {
+        return targets;
+    }
+    return targets.filter((target) => target.client === client);
+}
+function ensureParentDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+function readTextIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, "utf8");
+}
+function normalizeTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildCodexManagedBlock(packageSpecifier) {
+    return [
+        MANAGED_BLOCK_START,
+        "[mcp_servers.satori]",
+        'command = "npx"',
+        `args = ["-y", "--package", "${packageSpecifier}", "satori"]`,
+        `startup_timeout_ms = ${MANAGED_TIMEOUT_MS}`,
+        MANAGED_BLOCK_END,
+        "",
+    ].join("\n");
+}
+function codexHasUnmanagedSatoriSection(content) {
+    if (!content.includes("[mcp_servers.satori]")) {
+        return false;
+    }
+    return !(content.includes(MANAGED_BLOCK_START) && content.includes(MANAGED_BLOCK_END));
+}
+function prepareCodexInstall(filePath, packageSpecifier) {
+    const current = readTextIfExists(filePath) ?? "";
+    if (codexHasUnmanagedSatoriSection(current)) {
+        throw new CliError("E_USAGE", `Refusing to overwrite unmanaged Satori config in ${filePath}. Remove [mcp_servers.satori] manually or convert it to the managed block first.`, 2);
+    }
+    const managedBlock = buildCodexManagedBlock(packageSpecifier);
+    let next = current;
+    if (current.includes(MANAGED_BLOCK_START) && current.includes(MANAGED_BLOCK_END)) {
+        next = current.replace(new RegExp(`${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}\\n?`, "m"), managedBlock);
+    }
+    else if (current.trim().length === 0) {
+        next = managedBlock;
+    }
+    else {
+        next = `${normalizeTrailingNewline(current)}\n${managedBlock}`;
+    }
+    return {
+        changed: next !== current,
+        apply: () => {
+            if (next === current) {
+                return;
+            }
+            ensureParentDir(filePath);
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareCodexUninstall(filePath) {
+    const current = readTextIfExists(filePath);
+    if (!current) {
+        return { changed: false, apply: () => { } };
+    }
+    if (codexHasUnmanagedSatoriSection(current)) {
+        throw new CliError("E_USAGE", `Refusing to remove unmanaged Satori config in ${filePath}. Remove [mcp_servers.satori] manually instead.`, 2);
+    }
+    if (!current.includes(MANAGED_BLOCK_START) || !current.includes(MANAGED_BLOCK_END)) {
+        return { changed: false, apply: () => { } };
+    }
+    const next = current
+        .replace(new RegExp(`\\n?${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}\\n?`, "m"), "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/^\n+/, "");
+    return {
+        changed: next !== current,
+        apply: () => {
+            if (next === current) {
+                return;
+            }
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function parseJsonObject(filePath) {
+    const current = readTextIfExists(filePath);
+    if (!current) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(current);
+    }
+    catch (error) {
+        throw new CliError("E_USAGE", `Failed to parse JSON config at ${filePath}: ${error.message}`, 2);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new CliError("E_USAGE", `Expected top-level JSON object in ${filePath}.`, 2);
+    }
+    return parsed;
+}
+function buildClaudeServerConfig(packageSpecifier) {
+    return {
+        command: "npx",
+        args: ["-y", "--package", packageSpecifier, "satori"],
+        timeout: MANAGED_TIMEOUT_MS,
+    };
+}
+function isManagedClaudeEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const entry = value;
+    if (entry.command !== "npx") {
+        return false;
+    }
+    if (entry.timeout !== MANAGED_TIMEOUT_MS) {
+        return false;
+    }
+    if (!Array.isArray(entry.args) || entry.args.length !== 4) {
+        return false;
+    }
+    return entry.args[0] === "-y"
+        && entry.args[1] === "--package"
+        && typeof entry.args[2] === "string"
+        && /^@zokizuan\/satori-mcp@.+$/.test(entry.args[2])
+        && entry.args[3] === "satori";
+}
+function prepareClaudeInstall(filePath, packageSpecifier) {
+    const currentObject = parseJsonObject(filePath);
+    const currentSerialized = JSON.stringify(currentObject);
+    const desiredServer = buildClaudeServerConfig(packageSpecifier);
+    const mcpServersValue = currentObject.mcpServers;
+    let mcpServers;
+    if (mcpServersValue === undefined) {
+        mcpServers = {};
+    }
+    else if (mcpServersValue && typeof mcpServersValue === "object" && !Array.isArray(mcpServersValue)) {
+        mcpServers = { ...mcpServersValue };
+    }
+    else {
+        throw new CliError("E_USAGE", `Expected mcpServers to be an object in ${filePath}.`, 2);
+    }
+    const existingSatori = mcpServers.satori;
+    if (existingSatori !== undefined && !isManagedClaudeEntry(existingSatori)) {
+        throw new CliError("E_USAGE", `Refusing to overwrite unmanaged Satori config in ${filePath}. Remove mcpServers.satori manually or align it to the managed npx form first.`, 2);
+    }
+    mcpServers.satori = {
+        ...existingSatori,
+        ...desiredServer,
+    };
+    currentObject.mcpServers = mcpServers;
+    const next = `${JSON.stringify(currentObject, null, 2)}\n`;
+    return {
+        changed: JSON.stringify(currentObject) !== currentSerialized,
+        apply: () => {
+            if (JSON.stringify(currentObject) === currentSerialized) {
+                return;
+            }
+            ensureParentDir(filePath);
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareClaudeUninstall(filePath) {
+    const currentObject = parseJsonObject(filePath);
+    const mcpServersValue = currentObject.mcpServers;
+    if (!mcpServersValue || typeof mcpServersValue !== "object" || Array.isArray(mcpServersValue)) {
+        return { changed: false, apply: () => { } };
+    }
+    const mcpServers = { ...mcpServersValue };
+    if (!Object.prototype.hasOwnProperty.call(mcpServers, "satori")) {
+        return { changed: false, apply: () => { } };
+    }
+    if (!isManagedClaudeEntry(mcpServers.satori)) {
+        throw new CliError("E_USAGE", `Refusing to remove unmanaged Satori config in ${filePath}. Remove mcpServers.satori manually instead.`, 2);
+    }
+    delete mcpServers.satori;
+    if (Object.keys(mcpServers).length === 0) {
+        delete currentObject.mcpServers;
+    }
+    else {
+        currentObject.mcpServers = mcpServers;
+    }
+    const next = `${JSON.stringify(currentObject, null, 2)}\n`;
+    return {
+        changed: true,
+        apply: () => {
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareSkillInstall(skillsPath, skillAssetRoot) {
+    const writes = [];
+    let changed = false;
+    for (const skillDirName of OWNED_SKILL_DIRS) {
+        const sourceFile = path.join(skillAssetRoot, skillDirName, "SKILL.md");
+        if (!fs.existsSync(sourceFile)) {
+            throw new CliError("E_USAGE", `Missing packaged skill asset: ${sourceFile}`, 2);
+        }
+        const content = fs.readFileSync(sourceFile, "utf8");
+        const destinationDir = path.join(skillsPath, skillDirName);
+        const destinationFile = path.join(destinationDir, "SKILL.md");
+        if (readTextIfExists(destinationFile) !== content) {
+            changed = true;
+            writes.push({ destinationDir, destinationFile, content });
+        }
+    }
+    return {
+        changed,
+        apply: () => {
+            for (const write of writes) {
+                ensureDir(write.destinationDir);
+                fs.writeFileSync(write.destinationFile, write.content, "utf8");
+            }
+        },
+    };
+}
+function prepareSkillRemoval(skillsPath) {
+    const removals = OWNED_SKILL_DIRS
+        .map((skillDirName) => path.join(skillsPath, skillDirName))
+        .filter((destinationDir) => fs.existsSync(destinationDir));
+    return {
+        changed: removals.length > 0,
+        apply: () => {
+            for (const destinationDir of removals) {
+                fs.rmSync(destinationDir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+function prepareMutation(target, command, packageSpecifier, skillAssetRoot) {
+    const configMutation = command.kind === "install"
+        ? target.client === "codex"
+            ? prepareCodexInstall(target.configPath, packageSpecifier)
+            : prepareClaudeInstall(target.configPath, packageSpecifier)
+        : target.client === "codex"
+            ? prepareCodexUninstall(target.configPath)
+            : prepareClaudeUninstall(target.configPath);
+    const skillsMutation = command.kind === "install"
+        ? prepareSkillInstall(target.skillsPath, skillAssetRoot)
+        : prepareSkillRemoval(target.skillsPath);
+    return {
+        target,
+        configChanged: configMutation.changed,
+        skillsChanged: skillsMutation.changed,
+        apply: () => {
+            configMutation.apply();
+            skillsMutation.apply();
+        },
+    };
+}
+export function executeInstallCommand(command, options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const packageSpecifier = options.packageSpecifier ?? resolveDefaultPackageSpecifier();
+    const skillAssetRoot = options.skillAssetRoot ?? resolveDefaultSkillAssetRoot();
+    const prepared = selectTargets(homeDir, command.client).map((target) => (prepareMutation(target, command, packageSpecifier, skillAssetRoot)));
+    if (!command.dryRun) {
+        for (const mutation of prepared) {
+            mutation.apply();
+        }
+    }
+    return {
+        action: command.kind,
+        client: command.client,
+        dryRun: command.dryRun,
+        results: prepared.map((mutation) => ({
+            client: mutation.target.client,
+            configPath: mutation.target.configPath,
+            skillsPath: mutation.target.skillsPath,
+            configChanged: mutation.configChanged,
+            skillsChanged: mutation.skillsChanged,
+            status: mutation.configChanged || mutation.skillsChanged ? "updated" : "unchanged",
+            dryRun: command.dryRun,
+        })),
+    };
+}
+//# sourceMappingURL=install.js.map

package/dist/cli/package-installability.d.ts

@@ -0,0 +1,14 @@
+import { execFileSync } from "node:child_process";
+type ExecFileSyncLike = typeof execFileSync;
+export interface PackageInstallabilityOptions {
+    packageJsonPath?: string;
+    execFileSyncImpl?: ExecFileSyncLike;
+}
+export interface ReleaseSmokeOptions extends PackageInstallabilityOptions {
+    packageRoot?: string;
+    tempDir?: string;
+}
+export declare function verifyManagedPackageInstallability(options?: PackageInstallabilityOptions): string;
+export declare function runPublishedPackageReleaseSmoke(options?: ReleaseSmokeOptions): void;
+export {};
+//# sourceMappingURL=package-installability.d.ts.map

package/dist/cli/package-installability.js

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { CliError } from "./errors.js";
+function resolveDefaultPackageJsonPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), "..", "..", "package.json");
+}
+function readPackageJson(packageJsonPath) {
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+function looksLikeExactVersion(value) {
+    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value);
+}
+function npmOutput(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const stdout = "stdout" in error && typeof error.stdout === "string"
+        ? error.stdout
+        : "";
+    const stderr = "stderr" in error && typeof error.stderr === "string"
+        ? error.stderr
+        : "";
+    return `${stdout}\n${stderr}\n${error.message}`.trim();
+}
+function resolveWorkspaceDependencyVersion(packageJsonPath, dependencyName) {
+    const packageRoot = path.dirname(packageJsonPath);
+    const repoRoot = path.resolve(packageRoot, "..", "..");
+    const packagesRoot = path.join(repoRoot, "packages");
+    if (!fs.existsSync(packagesRoot)) {
+        return null;
+    }
+    for (const entry of fs.readdirSync(packagesRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const candidatePath = path.join(packagesRoot, entry.name, "package.json");
+        if (!fs.existsSync(candidatePath)) {
+            continue;
+        }
+        const candidate = readPackageJson(candidatePath);
+        if (candidate.name === dependencyName && looksLikeExactVersion(candidate.version)) {
+            return candidate.version;
+        }
+    }
+    return null;
+}
+function assertPublishedVersion(packageName, version, ownerPackageName, ownerPackageVersion, execImpl, relation) {
+    try {
+        execImpl("npm", ["view", `${packageName}@${version}`, "version", "--json"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        if (relation === "self") {
+            throw new CliError("E_USAGE", `Cannot install ${ownerPackageName}@${ownerPackageVersion} because that package version is not published on npm. Publish ${ownerPackageName}@${ownerPackageVersion} first or use a local dev server config instead.`, 2);
+        }
+        throw new CliError("E_USAGE", `Cannot install ${ownerPackageName}@${ownerPackageVersion} because required dependency ${packageName}@${version} is not published on npm. Publish ${packageName}@${version} first, then rerun satori-cli install.`, 2);
+    }
+}
+export function verifyManagedPackageInstallability(options = {}) {
+    const packageJsonPath = options.packageJsonPath ?? resolveDefaultPackageJsonPath();
+    const execImpl = options.execFileSyncImpl ?? execFileSync;
+    const pkg = readPackageJson(packageJsonPath);
+    const packageSpecifier = `${pkg.name}@${pkg.version}`;
+    assertPublishedVersion(pkg.name, pkg.version, pkg.name, pkg.version, execImpl, "self");
+    for (const [dependencyName, rawDependencyVersion] of Object.entries(pkg.dependencies ?? {})) {
+        const dependencyVersion = looksLikeExactVersion(rawDependencyVersion)
+            ? rawDependencyVersion
+            : rawDependencyVersion.startsWith("workspace:")
+                ? resolveWorkspaceDependencyVersion(packageJsonPath, dependencyName)
+                : null;
+        if (!dependencyVersion) {
+            continue;
+        }
+        assertPublishedVersion(dependencyName, dependencyVersion, pkg.name, pkg.version, execImpl, "dependency");
+    }
+    return packageSpecifier;
+}
+export function runPublishedPackageReleaseSmoke(options = {}) {
+    const packageJsonPath = options.packageJsonPath ?? resolveDefaultPackageJsonPath();
+    const packageRoot = options.packageRoot ?? path.dirname(packageJsonPath);
+    const tempDir = options.tempDir ?? os.tmpdir();
+    const execImpl = options.execFileSyncImpl ?? execFileSync;
+    verifyManagedPackageInstallability({ packageJsonPath, execFileSyncImpl: execImpl });
+    const smokePackDir = fs.mkdtempSync(path.join(tempDir, "satori-release-smoke-"));
+    const smokeExecDir = fs.mkdtempSync(path.join(tempDir, "satori-release-exec-"));
+    const beforeFiles = new Set(fs.readdirSync(smokePackDir));
+    execImpl("pnpm", ["pack", "--pack-destination", smokePackDir], {
+        cwd: packageRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const tarballName = fs.readdirSync(smokePackDir).find((entry) => entry.endsWith(".tgz") && !beforeFiles.has(entry));
+    if (!tarballName) {
+        throw new CliError("E_USAGE", "Release smoke failed: pnpm pack did not produce a tarball.", 2);
+    }
+    const tarballPath = path.join(smokePackDir, tarballName);
+    try {
+        execImpl("npm", ["exec", "--yes", "--package", tarballPath, "--", "satori", "--help"], {
+            cwd: smokeExecDir,
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                npm_config_package_lock: "false",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const output = npmOutput(error);
+        const pkg = readPackageJson(packageJsonPath);
+        throw new CliError("E_USAGE", `Release smoke failed for ${pkg.name}@${pkg.version}. The packed tarball did not start via 'npm exec --yes --package <tarball> -- satori --help'. ${output}`, 2);
+    }
+    finally {
+        fs.rmSync(smokePackDir, { recursive: true, force: true });
+        fs.rmSync(smokeExecDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=package-installability.js.map

package/dist/config.js

@@ -169,7 +169,7 @@ export function showHelpMessage() {
     console.log(`
 Satori MCP Server
 
-Usage: npx @zokizuan/satori-mcp@latest [options]
+Usage: npx -y @zokizuan/satori-mcp@4.4.1 [options]
 
 Options:
   --help, -h                          Show this help message
@@ -206,16 +206,16 @@ Environment Variables:
 
 Examples:
   # Start MCP server with OpenAI and explicit Milvus address
-  OPENAI_API_KEY=sk-xxx MILVUS_ADDRESS=localhost:19530 npx @zokizuan/satori-mcp@latest
+  OPENAI_API_KEY=sk-xxx MILVUS_ADDRESS=localhost:19530 npx -y @zokizuan/satori-mcp@4.4.1
 
   # Start MCP server with VoyageAI and specific model
-  EMBEDDING_PROVIDER=VoyageAI VOYAGEAI_API_KEY=pa-xxx EMBEDDING_MODEL=voyage-4-large MILVUS_TOKEN=your-token npx @zokizuan/satori-mcp@latest
+  EMBEDDING_PROVIDER=VoyageAI VOYAGEAI_API_KEY=pa-xxx EMBEDDING_MODEL=voyage-4-large MILVUS_TOKEN=your-token npx -y @zokizuan/satori-mcp@4.4.1
 
   # Start MCP server with Gemini and specific model
-  EMBEDDING_PROVIDER=Gemini GEMINI_API_KEY=xxx EMBEDDING_MODEL=gemini-embedding-001 MILVUS_TOKEN=your-token npx @zokizuan/satori-mcp@latest
+  EMBEDDING_PROVIDER=Gemini GEMINI_API_KEY=xxx EMBEDDING_MODEL=gemini-embedding-001 MILVUS_TOKEN=your-token npx -y @zokizuan/satori-mcp@4.4.1
 
   # Start MCP server with Ollama and specific model
-  EMBEDDING_PROVIDER=Ollama EMBEDDING_MODEL=nomic-embed-text MILVUS_TOKEN=your-token npx @zokizuan/satori-mcp@latest
+  EMBEDDING_PROVIDER=Ollama EMBEDDING_MODEL=nomic-embed-text MILVUS_TOKEN=your-token npx -y @zokizuan/satori-mcp@4.4.1
         `);
 }
 //# sourceMappingURL=config.js.map

package/dist/core/handlers.d.ts

@@ -24,6 +24,8 @@ export declare class ToolHandlers {
     private buildReindexHint;
     private buildCreateHint;
     private buildStatusHint;
+    private touchWatchedCodebase;
+    private unwatchCodebase;
     private buildManageResponseEnvelope;
     private manageResponseFromEnvelope;
     private manageResponse;

package/dist/core/handlers.js

@@ -153,6 +153,26 @@ export class ToolHandlers {
             }
         };
     }
+    async touchWatchedCodebase(codebasePath) {
+        const syncManager = this.syncManager;
+        if (typeof syncManager.touchWatchedCodebase === 'function') {
+            await syncManager.touchWatchedCodebase(codebasePath);
+            return;
+        }
+        if (typeof syncManager.registerCodebaseWatcher === 'function') {
+            await syncManager.registerCodebaseWatcher(codebasePath);
+        }
+    }
+    async unwatchCodebase(codebasePath) {
+        const syncManager = this.syncManager;
+        if (typeof syncManager.unwatchCodebase === 'function') {
+            await syncManager.unwatchCodebase(codebasePath);
+            return;
+        }
+        if (typeof syncManager.unregisterCodebaseWatcher === 'function') {
+            await syncManager.unregisterCodebaseWatcher(codebasePath);
+        }
+    }
     buildManageResponseEnvelope(action, codebasePath, status, humanText, options = {}) {
         const envelope = {
             tool: "manage_index",
@@ -1961,7 +1981,7 @@ Agent instructions:
             this.snapshotManager.removeCodebaseCompletely(droppedCodebasePath);
             this.snapshotManager.saveCodebaseSnapshot();
             try {
-                await this.syncManager.unregisterCodebaseWatcher(droppedCodebasePath);
+                await this.unwatchCodebase(droppedCodebasePath);
             }
             catch {
                 // Best-effort watcher cleanup; dropping cloud collection remains successful.
@@ -2148,7 +2168,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                 this.snapshotManager.removeCodebaseCompletely(absolutePath);
                 this.snapshotManager.saveCodebaseSnapshot();
                 try {
-                    await this.syncManager.unregisterCodebaseWatcher(absolutePath);
+                    await this.unwatchCodebase(absolutePath);
                 }
                 catch {
                     // Best-effort watcher cleanup before force rebuild.
@@ -2221,6 +2241,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
             this.snapshotManager.saveCodebaseSnapshot();
             // Track the codebase path for syncing
             trackCodebasePath(absolutePath);
+            await this.touchWatchedCodebase(absolutePath);
             // Start background indexing - now safe to proceed
             this.startBackgroundIndexing(absolutePath, forceReindex);
             const pathInfo = codebasePath !== absolutePath
@@ -2308,7 +2329,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
             // Save snapshot after updating codebase lists
             this.snapshotManager.saveCodebaseSnapshot();
             await this.rebuildCallGraphForIndex(absolutePath);
-            await this.syncManager.registerCodebaseWatcher(absolutePath);
+            await this.touchWatchedCodebase(absolutePath);
             let message = `Background indexing completed for '${absolutePath}'.\nIndexed ${stats.indexedFiles} files, ${stats.totalChunks} chunks.`;
             if (stats.status === 'limit_reached') {
                 message += `\n⚠️  Warning: Indexing stopped because the chunk limit (450,000) was reached. The index may be incomplete.`;
@@ -2931,6 +2952,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                     ...(Object.keys(responseHints).length > 0 ? { hints: responseHints } : {}),
                     results: rawResults
                 };
+                await this.touchWatchedCodebase(effectiveRoot);
                 return {
                     content: [{ type: "text", text: JSON.stringify(envelope, null, 2) }],
                     meta: { searchDiagnostics }
@@ -3073,6 +3095,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                 ...(Object.keys(responseHints).length > 0 ? { hints: responseHints } : {}),
                 results: visibleGroupedResults
             };
+            await this.touchWatchedCodebase(effectiveRoot);
             return {
                 content: [{ type: "text", text: JSON.stringify(envelope, null, 2) }],
                 meta: { searchDiagnostics }
@@ -3204,6 +3227,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
                 };
             }
+            await this.touchWatchedCodebase(effectiveRoot);
             if (!fs.existsSync(absoluteFile)) {
                 const payload = {
                     status: 'not_found',
@@ -3524,6 +3548,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                         }]
                 };
             }
+            await this.touchWatchedCodebase(effectiveRoot);
             const graph = this.callGraphManager.queryGraph(effectiveRoot, symbolRef, {
                 direction,
                 depth,
@@ -3610,7 +3635,7 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
             this.indexingStats = null;
             // Save snapshot after clearing index
             this.snapshotManager.saveCodebaseSnapshot();
-            await this.syncManager.unregisterCodebaseWatcher(absolutePath);
+            await this.unwatchCodebase(absolutePath);
             let resultText = `Successfully cleared codebase '${absolutePath}'`;
             const remainingIndexed = this.snapshotManager.getIndexedCodebases().length;
             const remainingIndexing = this.snapshotManager.getIndexingCodebases().length;
@@ -3889,10 +3914,12 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                         : '';
                     return this.manageResponse("sync", absolutePath, "error", `Error syncing codebase: coalesced in-flight reconcile failed (${decision.errorMessage}).${fallbackLine}`);
                 }
+                await this.touchWatchedCodebase(absolutePath);
                 return this.manageResponse("sync", absolutePath, "ok", `🔄 Sync request coalesced for '${absolutePath}'. Reused in-flight sync result.`);
             }
             if (decision.mode === 'reconciled_ignore_change') {
                 if (totalChanges === 0 && ignoredDeletes === 0) {
+                    await this.touchWatchedCodebase(absolutePath);
                     return this.manageResponse("sync", absolutePath, "ok", `✅ Ignore-rule reconciliation completed for '${absolutePath}'. No additional index changes were required.`);
                 }
                 const resultMessage = `🔄 Incremental sync + ignore-rule reconciliation completed for '${absolutePath}'.\n\n` +
@@ -3900,13 +3927,16 @@ To force rebuild from scratch: call manage_index with {"action":"create","path":
                     `🧹 Ignored paths removed from index: ${ignoredDeletes}\n` +
                     `\nTotal changes: ${totalChanges + ignoredDeletes}`;
                 console.log(`[SYNC] ✅ Sync+ignore reconcile completed: +${added}, -${removed}, ~${modified}, ignoredDeleted=${ignoredDeletes}`);
+                await this.touchWatchedCodebase(absolutePath);
                 return this.manageResponse("sync", absolutePath, "ok", resultMessage);
             }
             if (totalChanges === 0) {
+                await this.touchWatchedCodebase(absolutePath);
                 return this.manageResponse("sync", absolutePath, "ok", `✅ No changes detected for codebase '${absolutePath}'. Index is up to date.`);
             }
             const resultMessage = `🔄 Incremental sync completed for '${absolutePath}'.\n\n📊 Changes:\n+ ${added} file(s) added\n- ${removed} file(s) removed\n~ ${modified} file(s) modified\n\nTotal changes: ${totalChanges}`;
             console.log(`[SYNC] ✅ Sync completed: +${added}, -${removed}, ~${modified}`);
+            await this.touchWatchedCodebase(absolutePath);
             return this.manageResponse("sync", absolutePath, "ok", resultMessage);
         }
         catch (error) {

package/dist/core/sync.d.ts

@@ -53,6 +53,7 @@ export declare class SyncManager {
     private watcherModeStarted;
     private watchEnabled;
     private watchDebounceMs;
+    private watchedCodebases;
     private watchers;
     private debounceTimers;
     private watcherIgnoreMatchers;
@@ -87,8 +88,11 @@ export declare class SyncManager {
     private shouldIgnoreWatchPath;
     scheduleWatcherSync(codebasePath: string, reason?: WatchSyncReason): void;
     private handleWatcherError;
+    touchWatchedCodebase(codebasePath: string): Promise<void>;
+    unwatchCodebase(codebasePath: string): Promise<void>;
     registerCodebaseWatcher(codebasePath: string): Promise<void>;
     unregisterCodebaseWatcher(codebasePath: string): Promise<void>;
+    refreshWatchersFromWatchList(): Promise<void>;
     refreshWatchersFromSnapshot(): Promise<void>;
     startWatcherMode(): Promise<void>;
     stopWatcherMode(): Promise<void>;

package/dist/core/sync.js

@@ -11,6 +11,7 @@ export class SyncManager {
         this.lastSyncTimes = new Map();
         this.backgroundSyncTimer = null;
         this.watcherModeStarted = false;
+        this.watchedCodebases = new Set();
         this.watchers = new Map();
         this.debounceTimers = new Map();
         this.watcherIgnoreMatchers = new Map();
@@ -237,7 +238,7 @@ export class SyncManager {
             try {
                 this.snapshotManager.removeIndexedCodebase(codebasePath);
                 this.snapshotManager.saveCodebaseSnapshot();
-                await this.unregisterCodebaseWatcher(codebasePath);
+                await this.unwatchCodebase(codebasePath);
             }
             catch (e) {
                 console.error(`[SYNC] Failed to clean snapshot for '${codebasePath}':`, e);
@@ -488,6 +489,17 @@ export class SyncManager {
         }
         console.error(`[SYNC-WATCH] Watcher error for '${codebasePath}':`, error);
     }
+    async touchWatchedCodebase(codebasePath) {
+        this.watchedCodebases.add(codebasePath);
+        if (!this.watchEnabled || !this.watcherModeStarted) {
+            return;
+        }
+        await this.refreshWatchersFromWatchList();
+    }
+    async unwatchCodebase(codebasePath) {
+        this.watchedCodebases.delete(codebasePath);
+        await this.unregisterCodebaseWatcher(codebasePath);
+    }
     async registerCodebaseWatcher(codebasePath) {
         if (!this.watchEnabled || !this.watcherModeStarted) {
             return;
@@ -559,26 +571,29 @@ export class SyncManager {
             console.error(`[SYNC-WATCH] Failed to close watcher for '${codebasePath}':`, error);
         }
     }
-    async refreshWatchersFromSnapshot() {
+    async refreshWatchersFromWatchList() {
         if (!this.watchEnabled || !this.watcherModeStarted) {
             return;
         }
-        const indexedCodebases = new Set(this.snapshotManager.getIndexedCodebases());
+        const watchableCodebases = new Set(Array.from(this.watchedCodebases).filter((codebasePath) => this.canScheduleWatchSync(codebasePath)));
         for (const watchedPath of Array.from(this.watchers.keys())) {
-            if (!indexedCodebases.has(watchedPath)) {
+            if (!watchableCodebases.has(watchedPath)) {
                 await this.unregisterCodebaseWatcher(watchedPath);
             }
         }
-        for (const codebasePath of indexedCodebases) {
+        for (const codebasePath of watchableCodebases) {
             await this.registerCodebaseWatcher(codebasePath);
         }
     }
+    async refreshWatchersFromSnapshot() {
+        await this.refreshWatchersFromWatchList();
+    }
     async startWatcherMode() {
         if (!this.watchEnabled || this.watcherModeStarted) {
             return;
         }
         this.watcherModeStarted = true;
-        await this.refreshWatchersFromSnapshot();
+        await this.refreshWatchersFromWatchList();
         console.log(`[SYNC-WATCH] Watcher mode enabled.`);
     }
     async stopWatcherMode() {

package/dist/tools/read_file.js

@@ -102,6 +102,20 @@ function resolveCodebaseRootForFile(absolutePath, ctx) {
     }
     return candidates[0].path;
 }
+async function touchResolvedCodebaseRoot(absolutePath, ctx) {
+    const codebaseRoot = resolveCodebaseRootForFile(absolutePath, ctx);
+    if (!codebaseRoot) {
+        return;
+    }
+    const syncManager = ctx.syncManager;
+    if (typeof syncManager.touchWatchedCodebase === "function") {
+        await syncManager.touchWatchedCodebase(codebaseRoot);
+        return;
+    }
+    if (typeof syncManager.registerCodebaseWatcher === "function") {
+        await syncManager.registerCodebaseWatcher(codebaseRoot);
+    }
+}
 function resolveIndexingBlockForFile(absolutePath, ctx) {
     const allCodebases = typeof ctx.snapshotManager?.getAllCodebases === "function"
         ? ctx.snapshotManager.getAllCodebases()
@@ -200,6 +214,7 @@ export const readFileTool = {
                         }]
                 };
             }
+            await touchResolvedCodebaseRoot(absolutePath, ctx);
             const content = fs.readFileSync(absolutePath, "utf-8");
             const lines = splitIntoLines(content);
             const totalLines = lines.length;

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@zokizuan/satori-mcp",
-  "version": "4.3.1",
+  "version": "4.4.1",
   "description": "MCP server for Satori with agent-safe semantic search and indexing",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "satori": "dist/index.js",
-    "satori-cli": "dist/cli/index.js"
+    "satori": "dist/index.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
@@ -15,7 +14,7 @@
     "ignore": "^7.0.5",
     "zod": "^3.25.55",
     "zod-to-json-schema": "^3.25.1",
-    "@zokizuan/satori-core": "1.0.0"
+    "@zokizuan/satori-core": "1.1.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -42,7 +41,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "pnpm clean && tsc --build --force && pnpm fix:bin-perms && pnpm docs:generate",
+    "build": "pnpm clean && tsc --build --force && pnpm fix:bin-perms && pnpm docs:generate && pnpm manifest:generate",
+    "build:runtime": "pnpm clean && tsc --build --force && pnpm fix:bin-perms",
     "dev": "tsx --watch src/index.ts",
     "clean": "rimraf dist",
     "lint": "eslint src --ext .ts",
@@ -52,7 +52,10 @@
     "start:with-env": "OPENAI_API_KEY=${OPENAI_API_KEY:your-api-key-here} MILVUS_ADDRESS=${MILVUS_ADDRESS:localhost:19530} tsx src/index.ts",
     "docs:generate": "tsx scripts/generate-docs.ts",
     "docs:check": "tsx scripts/generate-docs.ts --check",
-    "fix:bin-perms": "node -e \"const fs=require('fs');try{fs.chmodSync('dist/index.js',0o755);fs.chmodSync('dist/cli/index.js',0o755);}catch(e){console.error(e);process.exit(1);}\"",
-    "test": "tsx --test --test-concurrency=1 src/**/*.test.ts"
+    "manifest:generate": "tsx scripts/generate-server-manifest.ts",
+    "manifest:check": "tsx scripts/generate-server-manifest.ts --check",
+    "release:smoke": "tsx scripts/release-smoke.ts",
+    "fix:bin-perms": "node -e \"const fs=require('fs');try{fs.chmodSync('dist/index.js',0o755);}catch(e){console.error(e);process.exit(1);}\"",
+    "test": "pnpm --filter @zokizuan/satori-core build && node --import tsx --test --test-concurrency=1 src/core/**/*.test.ts src/server/**/*.test.ts src/tools/**/*.test.ts src/cli/**/*.test.ts"
   }
 }