mdkg 0.4.1 → 0.5.0

package/dist/commands/loop_descriptors.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOOP_COMMAND_DESCRIPTORS = void 0;
+exports.loopDescriptorForSubcommand = loopDescriptorForSubcommand;
+const READ_ONLY_LOOP_SAFETY = {
+    json_schema_ref: "mdkg.command_output.v1",
+    side_effects: ["none"],
+    read_paths: [".mdkg/**"],
+    write_paths: [],
+    dry_run: { supported: false },
+    lock_policy: "none-read-only",
+    atomic_write_policy: "none-read-only",
+    receipts: ["loop-read-receipt"],
+    danger_level: "read-only",
+};
+const LOOP_GRAPH_WRITE_SAFETY = {
+    json_schema_ref: "mdkg.command_output.v1",
+    side_effects: [
+        "create-scoped-loop-and-optional-child-nodes",
+        "reserve-sqlite-node-ids-when-configured",
+        "rebuild-derived-indexes-when-auto-reindex-is-enabled",
+        "append-loop-fork-event-when-event-logging-is-enabled",
+    ],
+    read_paths: [".mdkg/**"],
+    write_paths: [".mdkg/**/*.md", ".mdkg/index/**", ".mdkg/events/*.jsonl"],
+    dry_run: {
+        supported: true,
+        flag: "--dry-run",
+        side_effects: ["none"],
+        write_paths: [],
+        reserves_ids: false,
+    },
+    lock_policy: "mutation-lock-required",
+    atomic_write_policy: "exclusive-create-and-atomic-file-writes",
+    receipts: ["loop-fork-receipt"],
+    danger_level: "moderate",
+};
+const JSON_FLAG = {
+    name: "--json",
+    value: null,
+    required: false,
+    description: "Emit deterministic JSON instead of text.",
+};
+const WS_FLAG = {
+    name: "--ws",
+    value: "<alias>",
+    required: false,
+    description: "Resolve the command against one workspace alias.",
+};
+const ROOT_FLAG = {
+    name: "--root",
+    value: "<path>",
+    required: false,
+    description: "Run against a specific repository root; -r is the short alias.",
+};
+const NO_CACHE_FLAG = {
+    name: "--no-cache",
+    value: null,
+    required: false,
+    description: "Build a non-persisting in-memory index projection instead of reading the cache.",
+};
+const NO_REINDEX_FLAG = {
+    name: "--no-reindex",
+    value: null,
+    required: false,
+    description: "Do not rebuild a stale or missing index projection.",
+};
+const RUN_ID_FLAG = {
+    name: "--run-id",
+    value: "<id>",
+    required: false,
+    description: "Attach an optional run id to the fork event when event logging is enabled.",
+};
+const READ_FLAGS = [ROOT_FLAG, WS_FLAG, JSON_FLAG, NO_CACHE_FLAG, NO_REINDEX_FLAG];
+exports.LOOP_COMMAND_DESCRIPTORS = [
+    {
+        key: "loop",
+        path: ["loop"],
+        summary: "mdkg loop command",
+        usage: [
+            "mdkg loop list [--ws <alias>] [--json]",
+            "mdkg loop show <loop-or-template> [--meta] [--ws <alias>] [--json]",
+            "mdkg loop fork <template> --scope <scope> [--title <title>] [--materialization default_children|planning_only|manual] [--planning-only] [--no-children] [--dry-run] [--run-id <id>] [--ws <alias>] [--json]",
+            "mdkg loop plan <loop> [--ws <alias>] [--json]",
+            "mdkg loop next <loop> [--ws <alias>] [--json]",
+            "mdkg loop runs <loop> [--ws <alias>] [--json]",
+        ],
+        args: [],
+        flags: [ROOT_FLAG, WS_FLAG, JSON_FLAG, NO_CACHE_FLAG, NO_REINDEX_FLAG, RUN_ID_FLAG],
+        output_formats: ["text", "json"],
+        notes: [
+            "loop is one first-class node type. Templates, scoped forks, and run-bearing loops are represented through metadata and links.",
+            "mdkg defines reusable process state and graph context; runtimes execute agents, tools, sandboxes, traces, and model routing.",
+        ],
+        safety: {
+            ...READ_ONLY_LOOP_SAFETY,
+            side_effects: ["read-or-write-loop-graph-state"],
+            write_paths: [".mdkg/**/*.md", ".mdkg/index/**", ".mdkg/events/*.jsonl"],
+            dry_run: { supported: true, commands: ["fork"] },
+            lock_policy: "mutation-lock-required-for-fork",
+            atomic_write_policy: "exclusive-create-and-atomic-file-writes",
+            receipts: ["loop-receipt"],
+            danger_level: "mixed",
+        },
+        handler: "runLoopSubcommand",
+    },
+    {
+        key: "loop list",
+        path: ["loop", "list"],
+        summary: "mdkg loop list command",
+        usage: ["mdkg loop list [--ws <alias>] [--no-cache] [--no-reindex] [--json]"],
+        args: [],
+        flags: READ_FLAGS,
+        output_formats: ["text", "json"],
+        notes: ["Lists indexed loop nodes and reusable seed loop templates."],
+        safety: { ...READ_ONLY_LOOP_SAFETY, receipts: ["loop-list-receipt"] },
+        handler: "runLoopListCommand",
+    },
+    {
+        key: "loop show",
+        path: ["loop", "show"],
+        summary: "mdkg loop show command",
+        usage: ["mdkg loop show <loop-or-template> [--meta] [--ws <alias>] [--no-cache] [--no-reindex] [--json]"],
+        args: [
+            {
+                name: "loop-or-template",
+                required: true,
+                source: "<loop-or-template>",
+                description: "Loop node id/qid or seed template name/ref.",
+            },
+        ],
+        flags: [
+            { name: "--meta", value: null, required: false, description: "Show metadata without the full body." },
+            ...READ_FLAGS,
+        ],
+        output_formats: ["text", "json"],
+        notes: ["Shows an indexed loop node or a seed loop template."],
+        safety: { ...READ_ONLY_LOOP_SAFETY, receipts: ["loop-show-receipt"] },
+        handler: "runLoopShowCommand",
+    },
+    {
+        key: "loop fork",
+        path: ["loop", "fork"],
+        summary: "mdkg loop fork command",
+        usage: [
+            "mdkg loop fork <template> --scope <scope> [--title <title>] [--materialization <mode>] [--planning-only] [--no-children] [--dry-run] [--run-id <id>] [--ws <alias>] [--no-cache] [--no-reindex] [--json]",
+        ],
+        args: [
+            { name: "template", required: true, source: "<template>", description: "Loop template node id/qid or seed template name/ref." },
+        ],
+        flags: [
+            { name: "--scope", value: "<scope>", required: true, description: "Scope ref, qid, URI, path, or description for the scoped loop." },
+            { name: "--title", value: "<title>", required: false, description: "Override the generated scoped loop title." },
+            { name: "--materialization", value: "<mode>", required: false, description: "Child materialization mode: default_children, planning_only, or manual." },
+            { name: "--planning-only", value: null, required: false, description: "Create only the scoped loop shell." },
+            { name: "--no-children", value: null, required: false, description: "Alias for planning-only materialization." },
+            { name: "--dry-run", value: null, required: false, description: "Plan the fork without writing loop or child nodes." },
+            RUN_ID_FLAG,
+            ROOT_FLAG,
+            WS_FLAG,
+            JSON_FLAG,
+            NO_CACHE_FLAG,
+            NO_REINDEX_FLAG,
+        ],
+        output_formats: ["text", "json"],
+        notes: [
+            "Seed templates resolve from .mdkg/templates/loops/<name>.loop.md.",
+            "Default forks create a scoped loop plus linked spike/task/test child nodes.",
+        ],
+        safety: LOOP_GRAPH_WRITE_SAFETY,
+        handler: "runLoopForkCommand",
+    },
+    {
+        key: "loop plan",
+        path: ["loop", "plan"],
+        summary: "mdkg loop plan command",
+        usage: ["mdkg loop plan <loop> [--ws <alias>] [--no-cache] [--no-reindex] [--json]"],
+        args: [
+            { name: "loop", required: true, source: "<loop>", description: "Loop node id or qid." },
+        ],
+        flags: READ_FLAGS,
+        output_formats: ["text", "json"],
+        notes: ["Read-only readiness cockpit for loop execution planning."],
+        safety: { ...READ_ONLY_LOOP_SAFETY, receipts: ["loop-plan-receipt"] },
+        handler: "runLoopPlanCommand",
+    },
+    {
+        key: "loop next",
+        path: ["loop", "next"],
+        summary: "mdkg loop next command",
+        usage: ["mdkg loop next <loop> [--ws <alias>] [--no-cache] [--no-reindex] [--json]"],
+        args: [
+            { name: "loop", required: true, source: "<loop>", description: "Loop node id or qid." },
+        ],
+        flags: READ_FLAGS,
+        output_formats: ["text", "json"],
+        notes: ["Read-only routing for the next actionable child, readiness lane, or blocker recovery step."],
+        safety: { ...READ_ONLY_LOOP_SAFETY, receipts: ["loop-next-receipt"] },
+        handler: "runLoopNextCommand",
+    },
+    {
+        key: "loop runs",
+        path: ["loop", "runs"],
+        summary: "mdkg loop runs command",
+        usage: ["mdkg loop runs <loop> [--ws <alias>] [--no-cache] [--no-reindex] [--json]"],
+        args: [
+            { name: "loop", required: true, source: "<loop>", description: "Loop node id or qid." },
+        ],
+        flags: READ_FLAGS,
+        output_formats: ["text", "json"],
+        notes: ["Lists run refs and evidence refs without executing runtime jobs."],
+        safety: { ...READ_ONLY_LOOP_SAFETY, receipts: ["loop-runs-receipt"] },
+        handler: "runLoopRunsCommand",
+    },
+];
+function loopDescriptorForSubcommand(subcommand) {
+    const key = subcommand ? `loop ${subcommand.toLowerCase()}` : "loop";
+    return exports.LOOP_COMMAND_DESCRIPTORS.find((descriptor) => descriptor.key === key) ?? exports.LOOP_COMMAND_DESCRIPTORS[0];
+}

package/dist/commands/mcp.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMcpRequest = handleMcpRequest;
 exports.handleMcpMessage = handleMcpMessage;
 exports.runMcpServeCommand = runMcpServeCommand;
-const readline_1 = __importDefault(require("readline"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const string_decoder_1 = require("string_decoder");
 const status_1 = require("./status");
 const validate_1 = require("./validate");
 const config_1 = require("../core/config");
@@ -33,6 +33,12 @@ const DEFAULT_SEARCH_LIMIT = 20;
 const MAX_PACK_NODES = 100;
 const DEFAULT_PACK_NODES = 20;
 const DEFAULT_PACK_MAX_CHARS = 120000;
+const MAX_MCP_LINE_BYTES = 1024 * 1024;
+const MAX_MCP_JSON_DEPTH = 64;
+const MAX_MCP_BATCH_ITEMS = 50;
+const MAX_MCP_SHOW_BODY_BYTES = 256 * 1024;
+const MAX_MCP_TOOL_PAYLOAD_BYTES = 512 * 1024;
+const MAX_MCP_RESPONSE_BYTES = 1024 * 1024;
 function objectSchema(properties, required = []) {
     return {
         type: "object",
@@ -312,6 +318,10 @@ function isConcreteGoalCandidate(node, statusRanks) {
     return node.status !== "done" && node.status !== "archived";
 }
 function toolResult(payload, isError = false) {
+    const compact = JSON.stringify(payload);
+    if (Buffer.byteLength(compact, "utf8") > MAX_MCP_TOOL_PAYLOAD_BYTES) {
+        throw new errors_1.UsageError(`MCP tool payload exceeds byte limit: ${MAX_MCP_TOOL_PAYLOAD_BYTES}`);
+    }
     return {
         content: [
             {
@@ -388,7 +398,7 @@ function showTool(root, args) {
     }
     return {
         command: "mcp.show",
-        item: (0, query_output_1.toNodeDetailJson)(node, metaOnly ? undefined : (0, node_body_1.readNodeBody)(root, node)),
+        item: (0, query_output_1.toNodeDetailJson)(node, metaOnly ? undefined : (0, node_body_1.readNodeBody)(root, node, MAX_MCP_SHOW_BODY_BYTES)),
     };
 }
 function packTool(root, args) {
@@ -414,6 +424,8 @@ function packTool(root, args) {
         verboseCoreListPath: path_1.default.resolve(root, config.pack.verbose_core_list_path),
         wsHint: ws,
         includeLatestCheckpoint: true,
+        maxTraversalNodes: MAX_PACK_NODES * 10,
+        maxBodyBytes: maxChars,
     });
     const headingMap = resolvedProfile.bodyMode === "summary"
         ? (0, headings_1.loadTemplateHeadingMap)(root, config, Array.from(node_1.ALLOWED_TYPES))
@@ -617,6 +629,9 @@ function handleMcpRequest(context, raw) {
 }
 function handleMcpMessage(context, message) {
     if (Array.isArray(message)) {
+        if (message.length === 0 || message.length > MAX_MCP_BATCH_ITEMS) {
+            return [jsonRpcError(null, -32600, `batch item count must be between 1 and ${MAX_MCP_BATCH_ITEMS}`)];
+        }
         return message
             .map((item) => handleMcpRequest(context, item))
             .filter((item) => Boolean(item));
@@ -624,33 +639,108 @@ function handleMcpMessage(context, message) {
     const response = handleMcpRequest(context, message);
     return response ? [response] : [];
 }
+function jsonNestingWithinLimit(input) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (const character of input) {
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+        }
+        else if (character === "{" || character === "[") {
+            depth += 1;
+            if (depth > MAX_MCP_JSON_DEPTH) {
+                return false;
+            }
+        }
+        else if (character === "}" || character === "]") {
+            depth -= 1;
+        }
+    }
+    return true;
+}
+function writeBoundedMcpResponse(output, response) {
+    let serialized = JSON.stringify(response);
+    if (Buffer.byteLength(serialized, "utf8") > MAX_MCP_RESPONSE_BYTES) {
+        serialized = JSON.stringify(jsonRpcError(response.id, -32000, `MCP response exceeds byte limit: ${MAX_MCP_RESPONSE_BYTES}`));
+    }
+    output.write(`${serialized}\n`);
+}
 async function runMcpServeCommand(options) {
     if (!options.stdio) {
         throw new errors_1.UsageError("mdkg mcp serve requires --stdio");
     }
     const input = options.input ?? process.stdin;
     const output = options.output ?? process.stdout;
-    const lines = readline_1.default.createInterface({
-        input,
-        crlfDelay: Infinity,
-    });
     const context = { root: options.root };
-    for await (const line of lines) {
+    const decoder = new string_decoder_1.StringDecoder("utf8");
+    let pending = "";
+    let discardingOversizedLine = false;
+    const processLine = (line) => {
         const trimmed = line.trim();
         if (!trimmed) {
-            continue;
+            return;
+        }
+        if (!jsonNestingWithinLimit(trimmed)) {
+            writeBoundedMcpResponse(output, jsonRpcError(null, -32600, `JSON nesting exceeds limit: ${MAX_MCP_JSON_DEPTH}`));
+            return;
         }
         let parsed;
         try {
             parsed = JSON.parse(trimmed);
         }
         catch {
-            output.write(`${JSON.stringify(jsonRpcError(null, -32700, "Parse error"))}\n`);
-            continue;
+            writeBoundedMcpResponse(output, jsonRpcError(null, -32700, "Parse error"));
+            return;
         }
         for (const response of handleMcpMessage(context, parsed)) {
-            output.write(`${JSON.stringify(response)}\n`);
+            writeBoundedMcpResponse(output, response);
+        }
+    };
+    for await (const chunk of input) {
+        const text = decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        let start = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            if (text[index] !== "\n") {
+                continue;
+            }
+            const segment = text.slice(start, index).replace(/\r$/, "");
+            if (discardingOversizedLine) {
+                discardingOversizedLine = false;
+            }
+            else if (Buffer.byteLength(pending, "utf8") + Buffer.byteLength(segment, "utf8") > MAX_MCP_LINE_BYTES) {
+                writeBoundedMcpResponse(output, jsonRpcError(null, -32600, `request line exceeds byte limit: ${MAX_MCP_LINE_BYTES}`));
+            }
+            else {
+                processLine(pending + segment);
+            }
+            pending = "";
+            start = index + 1;
         }
+        if (start < text.length && !discardingOversizedLine) {
+            pending += text.slice(start);
+            if (Buffer.byteLength(pending, "utf8") > MAX_MCP_LINE_BYTES) {
+                pending = "";
+                discardingOversizedLine = true;
+                writeBoundedMcpResponse(output, jsonRpcError(null, -32600, `request line exceeds byte limit: ${MAX_MCP_LINE_BYTES}`));
+            }
+        }
+    }
+    pending += decoder.end();
+    if (!discardingOversizedLine && pending.trim()) {
+        processLine(pending);
     }
     return 0;
 }

package/dist/commands/new.js

@@ -18,7 +18,8 @@ const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
 const id_1 = require("../util/id");
 const refs_1 = require("../util/refs");
-const atomic_1 = require("../util/atomic");
+const filesystem_authority_1 = require("../core/filesystem_authority");
+const workspace_path_1 = require("../core/workspace_path");
 const lock_1 = require("../util/lock");
 const sqlite_index_1 = require("../graph/sqlite_index");
 const reindex_1 = require("../graph/reindex");
@@ -30,6 +31,38 @@ const CONTRACT_METADATA_RE = /^[a-z][a-z0-9_]*(?:-[a-z0-9_]+)*$/;
 const CORE_TYPES = new Set(["rule"]);
 const DESIGN_TYPES = new Set(["prd", "edd", "dec", "prop"]);
 const LEGACY_NEW_SPEC_WARNING = "warning: mdkg new spec is legacy; use mdkg new manifest. This alias creates MANIFEST.md with type: manifest during the compatibility release.";
+const NEW_LOOP_NEXT_ACTIONS = [
+    "Review reusable loop templates with mdkg loop list",
+    "Fork a reusable template with mdkg loop fork <template> --scope <scope>",
+    "Inspect raw loop readiness with mdkg loop plan <loop-id>",
+];
+function toPosix(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function loopTemplateSuggestions(root, config) {
+    const dir = path_1.default.resolve(root, config.templates.root_path, "loops");
+    if (!fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((entry) => entry.endsWith(".loop.md"))
+        .sort()
+        .map((entry) => {
+        const filePath = path_1.default.join(dir, entry);
+        const content = fs_1.default.readFileSync(filePath, "utf8");
+        const { frontmatter } = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+        const slug = entry.replace(/\.loop\.md$/, "");
+        const title = typeof frontmatter.title === "string" && frontmatter.title.trim().length > 0
+            ? frontmatter.title
+            : slug;
+        return {
+            ref: `template://loops/${slug}`,
+            title,
+            path: toPosix(path_1.default.relative(root, filePath)),
+        };
+    });
+}
 function parseCsvList(raw) {
     if (!raw) {
         return [];
@@ -249,9 +282,10 @@ function runNewCommandLocked(options) {
     const fileName = fileNameForType(type, id, slug);
     const wsEntry = config.workspaces[ws];
     const folder = folderForType(type);
+    const relativeFilePath = (0, workspace_path_1.workspaceDocumentRelativePath)(wsEntry.path, wsEntry.mdkg_dir, folder, fileName);
     const targetDir = path_1.default.resolve(options.root, wsEntry.path, wsEntry.mdkg_dir, folder);
     const filePath = path_1.default.join(targetDir, fileName);
-    if (fs_1.default.existsSync(filePath)) {
+    if ((0, filesystem_authority_1.containedPathExists)({ root: options.root, relativePath: relativeFilePath })) {
         throw new errors_1.UsageError(`node already exists: ${path_1.default.relative(options.root, filePath)}`);
     }
     const statusInput = options.status?.toLowerCase();
@@ -410,7 +444,7 @@ function runNewCommandLocked(options) {
         redaction_class: redactionClass,
     });
     try {
-        (0, atomic_1.writeFileExclusive)(filePath, content);
+        (0, filesystem_authority_1.writeContainedFileExclusive)({ root: options.root, relativePath: relativeFilePath }, content);
     }
     catch (err) {
         const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
@@ -447,14 +481,26 @@ function runNewCommandLocked(options) {
     if (legacySpecAlias) {
         console.error(LEGACY_NEW_SPEC_WARNING);
     }
+    const loopGuidance = type === "loop"
+        ? {
+            next_actions: NEW_LOOP_NEXT_ACTIONS,
+            suggested_templates: loopTemplateSuggestions(options.root, config),
+        }
+        : undefined;
     if (options.json) {
         console.log(JSON.stringify({
             action: "created",
             node: receipt,
+            ...(loopGuidance ? loopGuidance : {}),
         }, null, 2));
         return;
     }
     console.log(`node created: ${receipt.qid} (${receipt.path})`);
+    if (loopGuidance) {
+        console.log("next: review reusable loop templates with `mdkg loop list`");
+        console.log("next: fork a reusable template with `mdkg loop fork <template> --scope <scope>`");
+        console.log(`next: inspect raw loop readiness with \`mdkg loop plan ${receipt.id}\``);
+    }
 }
 function runNewCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);

package/dist/commands/pack.js

@@ -7,6 +7,7 @@ exports.runPackCommand = runPackCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
+const filesystem_authority_1 = require("../core/filesystem_authority");
 const index_cache_1 = require("../graph/index_cache");
 const frontmatter_1 = require("../graph/frontmatter");
 const skills_index_cache_1 = require("../graph/skills_index_cache");
@@ -138,8 +139,12 @@ function loadSkillFullBody(root, skill) {
     if (!fs_1.default.existsSync(skillPath)) {
         return renderSkillMetaBody(skill);
     }
-    const content = fs_1.default.readFileSync(skillPath, "utf8");
-    return (0, frontmatter_1.parseFrontmatter)(content, skillPath).body.trimEnd();
+    const content = (0, filesystem_authority_1.readContainedFile)({ root, relativePath: skill.path }, "utf8");
+    const parsed = (0, frontmatter_1.parseFrontmatter)(content, skillPath);
+    if (parsed.frontmatter.name !== skill.name) {
+        throw new Error(`cached skill identity mismatch for ${skill.qid}`);
+    }
+    return parsed.body.trimEnd();
 }
 function uniqueSkillOrder(slugs) {
     const seen = new Set();
@@ -323,10 +328,13 @@ function runPackCommand(options) {
     if (ws && !config.workspaces[ws] && !config.subgraphs[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
+    const visibility = options.visibility
+        ? (0, visibility_1.normalizeVisibility)(options.visibility)
+        : undefined;
     const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
-        useCache: !options.noCache,
+        useCache: !options.noCache && !visibility,
         allowReindex: !options.noReindex,
     });
     if (stale && !rebuilt && !options.noCache) {
@@ -347,9 +355,6 @@ function runPackCommand(options) {
     const edges = normalizeEdges([...config.pack.default_edges, ...extraEdges]);
     const skillsPolicy = resolveSkillsPolicy(options.skills);
     const skillsDepth = resolveSkillsDepth(options.skillsDepth);
-    const visibility = options.visibility
-        ? (0, visibility_1.normalizeVisibility)(options.visibility)
-        : undefined;
     let resolvedProfile;
     try {
         resolvedProfile = (0, profile_1.resolvePackProfile)({
@@ -374,6 +379,8 @@ function runPackCommand(options) {
         edges,
         verbose: Boolean(options.verbose),
         maxNodes: config.pack.limits.max_nodes,
+        maxTraversalNodes: Math.min(config.index.limits.max_files, Math.max(1000, config.pack.limits.max_nodes * 10)),
+        maxBodyBytes: config.pack.limits.max_bytes,
         verboseCoreListPath: path_1.default.resolve(options.root, config.pack.verbose_core_list_path),
         wsHint: ws,
         includeLatestCheckpoint: true,
@@ -386,7 +393,7 @@ function runPackCommand(options) {
         const skillsLoad = (0, skills_index_cache_1.loadSkillsIndex)({
             root: options.root,
             config,
-            useCache: !options.noCache,
+            useCache: !options.noCache && !visibility,
             allowReindex: !options.noReindex,
         });
         if (skillsLoad.stale && !skillsLoad.rebuilt && !options.noCache) {

package/dist/commands/search.js

@@ -8,6 +8,7 @@ const errors_1 = require("../util/errors");
 const sort_1 = require("../util/sort");
 const node_card_1 = require("./node_card");
 const query_output_1 = require("./query_output");
+const DEFAULT_STRUCTURED_SEARCH_LIMIT = 50;
 function normalizeWorkspace(value) {
     if (!value || value === "all") {
         return undefined;
@@ -84,11 +85,19 @@ function runSearchCommand(options) {
     const sorted = (0, sort_1.sortNodesByQid)(nodeResults);
     const format = options.format ?? (options.json ? "json" : undefined);
     if (format) {
+        const limit = options.limit ?? DEFAULT_STRUCTURED_SEARCH_LIMIT;
+        if (!Number.isInteger(limit) || limit < 1) {
+            throw new errors_1.UsageError("--limit must be a positive integer");
+        }
+        const items = sorted.slice(0, limit);
         (0, query_output_1.writeStructuredOutput)({
             command: "search",
             kind: "node",
             count: sorted.length,
-            items: sorted.map(query_output_1.toNodeSummaryJson),
+            returned_count: items.length,
+            limit,
+            truncated: items.length < sorted.length,
+            items: items.map(query_output_1.toNodeSummaryJson),
         }, format);
         return;
     }

package/dist/commands/skill.js

@@ -12,6 +12,7 @@ exports.runSkillSyncCommand = runSkillSyncCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
+const filesystem_authority_1 = require("../core/filesystem_authority");
 const skills_indexer_1 = require("../graph/skills_indexer");
 const skills_index_cache_1 = require("../graph/skills_index_cache");
 const skills_index_cache_2 = require("../graph/skills_index_cache");
@@ -20,7 +21,6 @@ const skill_support_1 = require("./skill_support");
 const query_output_1 = require("./query_output");
 const event_support_1 = require("./event_support");
 const skill_mirror_1 = require("./skill_mirror");
-const atomic_1 = require("../util/atomic");
 const lock_1 = require("../util/lock");
 function parseCsvList(raw) {
     if (!raw) {
@@ -170,11 +170,12 @@ function runSkillNewCommandLocked(options) {
     if (fs_1.default.existsSync(canonicalPath) && !force) {
         throw new errors_1.UsageError(`skill already exists: ${path_1.default.relative(root, canonicalPath)} (use --force to overwrite)`);
     }
-    fs_1.default.mkdirSync(skillDir, { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(skillDir, "references"), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(skillDir, "assets"), { recursive: true });
+    const relativeSkillDir = path_1.default.relative(root, skillDir).split(path_1.default.sep).join("/");
+    (0, filesystem_authority_1.ensureContainedDirectory)({ root, relativePath: relativeSkillDir });
+    (0, filesystem_authority_1.ensureContainedDirectory)({ root, relativePath: `${relativeSkillDir}/references` });
+    (0, filesystem_authority_1.ensureContainedDirectory)({ root, relativePath: `${relativeSkillDir}/assets` });
     if (options.withScripts) {
-        fs_1.default.mkdirSync(path_1.default.join(skillDir, "scripts"), { recursive: true });
+        (0, filesystem_authority_1.ensureContainedDirectory)({ root, relativePath: `${relativeSkillDir}/scripts` });
     }
     const content = (0, skill_support_1.renderSkillTemplate)({
         name,
@@ -183,7 +184,7 @@ function runSkillNewCommandLocked(options) {
         authors,
         links,
     });
-    (0, atomic_1.atomicWriteFile)(canonicalPath, content);
+    (0, filesystem_authority_1.atomicReplaceContainedFile)({ root, relativePath: `${relativeSkillDir}/SKILL.md` }, content);
     (0, skill_support_1.ensureSkillsRegistry)(root, config);
     (0, skill_support_1.refreshSkillsRegistry)(root, config);
     if ((0, skill_mirror_1.shouldMaintainSkillMirrors)(root, config)) {
@@ -233,6 +234,7 @@ function runSkillListCommand(options) {
         config,
         useCache: !options.noCache,
         allowReindex: !options.noReindex,
+        persistReindex: false,
     });
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: skills index is stale; run mdkg index to refresh");
@@ -261,6 +263,7 @@ function runSkillShowCommand(options) {
         config,
         useCache: !options.noCache,
         allowReindex: !options.noReindex,
+        persistReindex: false,
     });
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: skills index is stale; run mdkg index to refresh");
@@ -269,13 +272,12 @@ function runSkillShowCommand(options) {
     if (!skill) {
         throw new errors_1.NotFoundError(`skill not found: ${slug}`);
     }
-    const skillPath = path_1.default.resolve(options.root, skill.path);
     let body = "";
     if (!options.metaOnly) {
-        if (!fs_1.default.existsSync(skillPath)) {
+        if (!(0, filesystem_authority_1.containedPathExists)({ root: options.root, relativePath: skill.path })) {
             throw new errors_1.NotFoundError(`file not found for ${skill.id}: ${skill.path}`);
         }
-        body = fs_1.default.readFileSync(skillPath, "utf8").trimEnd();
+        body = (0, filesystem_authority_1.readContainedFile)({ root: options.root, relativePath: skill.path }).trimEnd();
     }
     const format = options.format ?? (options.json ? "json" : undefined);
     if (format) {
@@ -347,6 +349,7 @@ function runSkillSearchCommand(options) {
         config,
         useCache: !options.noCache,
         allowReindex: !options.noReindex,
+        persistReindex: false,
     });
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: skills index is stale; run mdkg index to refresh");