@zhijiewang/openharness 2.8.0 → 2.9.0

package/dist/harness/memory.d.ts

@@ -31,6 +31,40 @@ export type MemoryEntry = {
 export declare function loadMemories(): MemoryEntry[];
 /** Build a system prompt section from loaded memories (capped at MEMORY_PROMPT_MAX_CHARS) */
 export declare function memoriesToPrompt(memories: MemoryEntry[]): string;
+/** A single CLAUDE.md source with its resolved content (imports inlined). */
+export type ClaudeMdEntry = {
+    path: string;
+    source: "project" | "project-local" | "user" | "claude-dir";
+    content: string;
+};
+/**
+ * Resolve `@path/to/file` imports inline. Relative paths resolve against
+ * `baseDir`. Absolute paths are read as-is. Each imported file can itself
+ * contain imports — recursion capped at `CLAUDE_MD_MAX_HOPS` to prevent
+ * cycles. Missing or unreadable imports are silently dropped.
+ *
+ * @internal exposed for testing
+ */
+export declare function resolveClaudeMdImports(content: string, baseDir: string, hopsLeft?: number): string;
+/**
+ * Load the hierarchical CLAUDE.md set in the order Anthropic documents:
+ *   1. `./.claude/CLAUDE.md` (project, checked in)
+ *   2. `./CLAUDE.md` (project, checked in)
+ *   3. `./CLAUDE.local.md` (project, gitignored)
+ *   4. `~/.claude/CLAUDE.md` (user-global)
+ *
+ * Each file is read, `@imports` are resolved, and the results are returned in
+ * load order. Missing files are skipped. The caller can format these into the
+ * system prompt alongside `memoriesToPrompt()` — the two systems are additive.
+ *
+ * @param root optional project root (defaults to cwd)
+ */
+export declare function loadClaudeMdHierarchy(root?: string): ClaudeMdEntry[];
+/**
+ * Render loaded CLAUDE.md entries as a system-prompt block. Empty when no
+ * CLAUDE.md files exist — caller should concatenate alongside `memoriesToPrompt`.
+ */
+export declare function claudeMdToPrompt(entries: ClaudeMdEntry[]): string;
 /** Save a memory entry to the project memory directory */
 export declare function saveMemory(name: string, type: MemoryType, description: string, content: string, global?: boolean): string;
 /**

package/dist/harness/memory.js

@@ -13,6 +13,10 @@ import { join, resolve, sep } from "node:path";
 import { createUserMessage } from "../types/message.js";
 const PROJECT_MEMORY_DIR = join(".oh", "memory");
 const GLOBAL_MEMORY_DIR = join(homedir(), ".oh", "memory");
+// Maximum number of @-import hops before giving up (prevents cycles).
+const CLAUDE_MD_MAX_HOPS = 5;
+// Cap per loaded CLAUDE.md source to keep the system prompt bounded.
+const CLAUDE_MD_PER_FILE_CAP = 20_000;
 // Version counter — incremented on every save, used by query loop for live injection
 let _memoryVersion = 0;
 export function memoryVersion() {
@@ -79,6 +83,98 @@ export function memoriesToPrompt(memories) {
     }
     return result.trimEnd();
 }
+/**
+ * Resolve `@path/to/file` imports inline. Relative paths resolve against
+ * `baseDir`. Absolute paths are read as-is. Each imported file can itself
+ * contain imports — recursion capped at `CLAUDE_MD_MAX_HOPS` to prevent
+ * cycles. Missing or unreadable imports are silently dropped.
+ *
+ * @internal exposed for testing
+ */
+export function resolveClaudeMdImports(content, baseDir, hopsLeft = CLAUDE_MD_MAX_HOPS) {
+    if (hopsLeft <= 0)
+        return content;
+    // Match `@path` on its own line or in a line-leading position. We avoid
+    // email addresses (`foo@bar.com`) by requiring whitespace/start-of-line
+    // before the `@` and a path-like token after.
+    const importRe = /(^|\s)@([^\s@]+)/g;
+    return content.replace(importRe, (match, leading, path) => {
+        // Skip obvious non-path tokens (e.g. `@user` mentions without slashes or extensions)
+        if (!path.includes("/") && !path.includes("."))
+            return match;
+        const resolved = path.startsWith("/") || path.startsWith("~") ? path.replace(/^~/, homedir()) : join(baseDir, path);
+        if (!existsSync(resolved))
+            return match;
+        try {
+            const raw = readFileSync(resolved, "utf-8");
+            const subDir = resolved.split(/[/\\]/).slice(0, -1).join("/");
+            const expanded = resolveClaudeMdImports(raw, subDir || baseDir, hopsLeft - 1);
+            return `${leading}<!-- imported from @${path} -->\n${expanded}\n<!-- end @${path} -->`;
+        }
+        catch {
+            return match;
+        }
+    });
+}
+/** Read a single CLAUDE.md candidate path if it exists. Returns null otherwise. */
+function readClaudeMdIfExists(path, source) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8").slice(0, CLAUDE_MD_PER_FILE_CAP);
+        const baseDir = path.split(/[/\\]/).slice(0, -1).join("/") || ".";
+        return { path, source, content: resolveClaudeMdImports(raw, baseDir) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load the hierarchical CLAUDE.md set in the order Anthropic documents:
+ *   1. `./.claude/CLAUDE.md` (project, checked in)
+ *   2. `./CLAUDE.md` (project, checked in)
+ *   3. `./CLAUDE.local.md` (project, gitignored)
+ *   4. `~/.claude/CLAUDE.md` (user-global)
+ *
+ * Each file is read, `@imports` are resolved, and the results are returned in
+ * load order. Missing files are skipped. The caller can format these into the
+ * system prompt alongside `memoriesToPrompt()` — the two systems are additive.
+ *
+ * @param root optional project root (defaults to cwd)
+ */
+export function loadClaudeMdHierarchy(root = ".") {
+    const candidates = [
+        [join(root, ".claude", "CLAUDE.md"), "claude-dir"],
+        [join(root, "CLAUDE.md"), "project"],
+        [join(root, "CLAUDE.local.md"), "project-local"],
+        [join(homedir(), ".claude", "CLAUDE.md"), "user"],
+    ];
+    const entries = [];
+    const seen = new Set();
+    for (const [path, source] of candidates) {
+        if (seen.has(path))
+            continue;
+        seen.add(path);
+        const entry = readClaudeMdIfExists(path, source);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Render loaded CLAUDE.md entries as a system-prompt block. Empty when no
+ * CLAUDE.md files exist — caller should concatenate alongside `memoriesToPrompt`.
+ */
+export function claudeMdToPrompt(entries) {
+    if (entries.length === 0)
+        return "";
+    const parts = ["# Project instructions (CLAUDE.md)"];
+    for (const e of entries) {
+        parts.push(`<!-- source: ${e.source} (${e.path}) -->`);
+        parts.push(e.content.trim());
+    }
+    return parts.join("\n\n").trimEnd();
+}
 /** Save a memory entry to the project memory directory */
 export function saveMemory(name, type, description, content, global = false) {
     const dir = global ? GLOBAL_MEMORY_DIR : PROJECT_MEMORY_DIR;

package/dist/harness/plugins.d.ts

@@ -16,9 +16,19 @@ export type SkillMetadata = {
     trigger: string | undefined;
     tools: string[] | undefined;
     args: string[] | undefined;
+    /** Optional natural-language hint for when this skill applies; concatenated to description for trigger matching */
+    whenToUse: string | undefined;
+    /** SPDX license identifier (e.g. "MIT", "Apache-2.0", "CC-BY-SA-4.0"). Used by install gate. */
+    license: string | undefined;
+    /** Glob patterns scoping skill auto-surfacing to specific file paths */
+    paths: string[] | undefined;
+    /** Execution context: "default" runs in the current agent, "fork" spawns a sub-agent (Anthropic extension) */
+    context: "default" | "fork" | undefined;
+    /** When `context: fork`, the sub-agent type to spawn (must match an AgentRole id) */
+    agent: string | undefined;
     content: string;
     filePath: string;
-    source: "project" | "global" | "plugin";
+    source: "bundled" | "project" | "global" | "plugin";
     /** When false, skill is hidden from system prompt until explicitly invoked */
     invokeModel: boolean;
 };
@@ -44,11 +54,11 @@ export type AgentTeamConfig = {
         tools?: string[];
     }>;
 };
-/** Discover all available skills from project + global dirs + installed plugins */
+/** Discover all available skills from bundled + project + global dirs + installed plugins */
 export declare function discoverSkills(): SkillMetadata[];
 /** Find a skill by name (case-insensitive) */
 export declare function findSkill(name: string): SkillMetadata | null;
-/** Find skills that match a trigger condition */
+/** Find skills that match a trigger condition (substring match against `trigger` field). */
 export declare function findTriggeredSkills(userMessage: string): SkillMetadata[];
 /** Find a skill similar to a candidate (for patch-vs-create decision) */
 export declare function findSimilarSkill(candidateName: string, candidateDescription: string, skills: Array<{

package/dist/harness/plugins.js

@@ -12,10 +12,31 @@
  */
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
 const PROJECT_SKILLS_DIR = join(".oh", "skills");
 const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
-/** Parse YAML frontmatter from a skill markdown file */
+// Claude Code ecosystem mirror paths (Anthropic convention)
+const CC_PROJECT_SKILLS_DIR = join(".claude", "skills");
+const CC_GLOBAL_SKILLS_DIR = join(homedir(), ".claude", "skills");
+// Bundled skills shipped with the openharness package itself.
+// At runtime this resolves to <package-root>/data/skills/ both in dev (src/) and prod (dist/).
+const BUNDLED_SKILLS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "data", "skills");
+/** Parse a frontmatter list value. Accepts `[a, b]` (YAML inline) or `a b c` (space-separated, Anthropic spec). */
+function parseListValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        return trimmed
+            .slice(1, -1)
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    // Strip surrounding quotes if present
+    const unquoted = trimmed.replace(/^["']|["']$/g, "");
+    return unquoted.split(/\s+/).filter(Boolean);
+}
+/** Parse YAML frontmatter from a skill markdown file. Accepts both OH camelCase and Anthropic kebab-case. */
 function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match)
@@ -28,33 +49,74 @@ function parseSkillFrontmatter(content) {
     const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
     if (descMatch)
         result.description = descMatch[1].trim();
+    // trigger: OH-native field; when-to-use / whenToUse: Anthropic-style hint (also used as trigger fallback)
     const triggerMatch = frontmatter.match(/^trigger:\s*(.+)$/m);
     if (triggerMatch)
         result.trigger = triggerMatch[1].trim();
-    const toolsMatch = frontmatter.match(/^tools:\s*\[(.+)\]$/m);
-    if (toolsMatch)
-        result.tools = toolsMatch[1].split(",").map((t) => t.trim());
-    // Also parse allowedTools (used by built-in skills) and merge with tools
-    const allowedToolsMatch = frontmatter.match(/^allowedTools:\s*\[(.+)\]$/m);
-    if (allowedToolsMatch) {
-        const allowed = allowedToolsMatch[1].split(",").map((t) => t.trim());
-        result.tools = result.tools ? [...new Set([...result.tools, ...allowed])] : allowed;
+    const whenToUseMatch = frontmatter.match(/^(?:when-to-use|whenToUse):\s*(.+)$/m);
+    if (whenToUseMatch)
+        result.whenToUse = whenToUseMatch[1].trim();
+    // tools / allowedTools / allowed-tools — array OR space-separated. Merge all forms found.
+    const toolsCollected = new Set();
+    for (const re of [/^tools:\s*(.+)$/m, /^allowedTools:\s*(.+)$/m, /^allowed-tools:\s*(.+)$/m]) {
+        const m = frontmatter.match(re);
+        if (m)
+            for (const t of parseListValue(m[1]))
+                toolsCollected.add(t);
     }
-    const argsMatch = frontmatter.match(/^args:\s*\[(.+)\]$/m);
+    if (toolsCollected.size > 0)
+        result.tools = [...toolsCollected];
+    // args / argument-hint
+    const argsMatch = frontmatter.match(/^(?:args|argument-hint):\s*(.+)$/m);
     if (argsMatch)
-        result.args = argsMatch[1].split(",").map((a) => a.trim());
+        result.args = parseListValue(argsMatch[1]);
     // invokeModel: false OR disable-model-invocation: true → hidden from system prompt
     if (frontmatter.match(/^invokeModel:\s*false$/m) || frontmatter.match(/^disable-model-invocation:\s*true$/m)) {
         result.invokeModel = false;
     }
+    // license: SPDX identifier (e.g. MIT, Apache-2.0)
+    const licenseMatch = frontmatter.match(/^license:\s*(.+)$/m);
+    if (licenseMatch)
+        result.license = licenseMatch[1].trim().replace(/^["']|["']$/g, "");
+    // paths: glob list — scopes auto-surfacing to matching files
+    const pathsMatch = frontmatter.match(/^paths:\s*(.+)$/m);
+    if (pathsMatch)
+        result.paths = parseListValue(pathsMatch[1]);
+    // context: "default" | "fork" — when "fork", skill runs in a new sub-agent context
+    const contextMatch = frontmatter.match(/^context:\s*(.+)$/m);
+    if (contextMatch) {
+        const v = contextMatch[1].trim().replace(/^["']|["']$/g, "");
+        if (v === "fork" || v === "default")
+            result.context = v;
+    }
+    // agent: sub-agent type name (only meaningful when context: fork)
+    const agentMatch = frontmatter.match(/^agent:\s*(.+)$/m);
+    if (agentMatch)
+        result.agent = agentMatch[1].trim().replace(/^["']|["']$/g, "");
     return result;
 }
-/** Recursively collect all .md files from a directory tree */
+/** Recursively collect skill .md files from a directory tree.
+ * Anthropic / Claude Code convention: a directory containing `SKILL.md` is a single
+ * directory-packaged skill — only the SKILL.md surfaces; sibling .md files are
+ * companion documentation (referenced via Read at runtime). Directories without
+ * SKILL.md fall through to the legacy flat-file behavior (every .md is a skill).
+ */
 function walkMdFiles(dir) {
     if (!existsSync(dir))
         return [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    // Directory-packaged skill: only SKILL.md counts; siblings are companions.
+    if (entries.includes("SKILL.md")) {
+        return [join(dir, "SKILL.md")];
+    }
     const results = [];
-    for (const entry of readdirSync(dir)) {
+    for (const entry of entries) {
         const full = join(dir, entry);
         try {
             if (statSync(full).isDirectory()) {
@@ -86,6 +148,11 @@ function loadSkillsFromDir(dir, source) {
                 trigger: meta.trigger,
                 tools: meta.tools,
                 args: meta.args,
+                whenToUse: meta.whenToUse,
+                license: meta.license,
+                paths: meta.paths,
+                context: meta.context,
+                agent: meta.agent,
                 content,
                 filePath,
                 source,
@@ -98,11 +165,17 @@ function loadSkillsFromDir(dir, source) {
     })
         .filter((s) => s !== null);
 }
-/** Discover all available skills from project + global dirs + installed plugins */
+/** Discover all available skills from bundled + project + global dirs + installed plugins */
 export function discoverSkills() {
     const skills = [];
+    // Bundled (shipped with the openharness package)
+    skills.push(...loadSkillsFromDir(BUNDLED_SKILLS_DIR, "bundled"));
+    // OH-native paths
     skills.push(...loadSkillsFromDir(PROJECT_SKILLS_DIR, "project"));
     skills.push(...loadSkillsFromDir(GLOBAL_SKILLS_DIR, "global"));
+    // Claude Code ecosystem mirror paths — same source labels (project/global)
+    skills.push(...loadSkillsFromDir(CC_PROJECT_SKILLS_DIR, "project"));
+    skills.push(...loadSkillsFromDir(CC_GLOBAL_SKILLS_DIR, "global"));
     // Load skills from installed marketplace plugins (namespaced as plugin-name:skill-name)
     try {
         const { getInstalledPlugins } = require("./marketplace.js");
@@ -119,14 +192,22 @@ export function discoverSkills() {
     catch {
         /* marketplace module may not be loaded yet */
     }
-    return skills;
+    // De-duplicate by name+filePath: if same skill appears in multiple paths (e.g. CC mirror), keep first.
+    const seen = new Set();
+    return skills.filter((s) => {
+        const key = `${s.name}::${s.filePath}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
 }
 /** Find a skill by name (case-insensitive) */
 export function findSkill(name) {
     const skills = discoverSkills();
     return skills.find((s) => s.name.toLowerCase() === name.toLowerCase()) ?? null;
 }
-/** Find skills that match a trigger condition */
+/** Find skills that match a trigger condition (substring match against `trigger` field). */
 export function findTriggeredSkills(userMessage) {
     const skills = discoverSkills();
     return skills.filter((s) => {

package/dist/harness/session-db.d.ts

@@ -48,7 +48,14 @@ export declare function sessionToIndexEntry(session: Session): SessionIndexEntry
  * Rebuilds the FTS5 index from session JSON files on disk.
  */
 export declare function rebuildIndex(db: Database.Database, sessionsDir?: string): number;
-/** Get a shared DB connection (opens once, reuses thereafter) */
+/**
+ * Get a shared DB connection (opens once, reuses thereafter).
+ *
+ * Honors the `OH_SESSION_DB_PATH` environment variable for test isolation.
+ * When the env var changes between calls, the old singleton is closed and a
+ * new one is opened at the new path — this lets tests point at a tmp dir
+ * without leaking into the user's real `~/.oh/sessions.db`.
+ */
 export declare function getSessionDb(): Database.Database;
 /** Close the singleton connection (call on process exit) */
 export declare function closeGlobalSessionDb(): void;

package/dist/harness/session-db.js

@@ -145,11 +145,32 @@ export function rebuildIndex(db, sessionsDir) {
 }
 // ── Singleton Connection ──
 let _singletonDb = null;
-/** Get a shared DB connection (opens once, reuses thereafter) */
+let _singletonDbPath = null;
+/**
+ * Get a shared DB connection (opens once, reuses thereafter).
+ *
+ * Honors the `OH_SESSION_DB_PATH` environment variable for test isolation.
+ * When the env var changes between calls, the old singleton is closed and a
+ * new one is opened at the new path — this lets tests point at a tmp dir
+ * without leaking into the user's real `~/.oh/sessions.db`.
+ */
 export function getSessionDb() {
-    if (!_singletonDb) {
-        _singletonDb = openSessionDb();
+    const envPath = process.env.OH_SESSION_DB_PATH;
+    const targetPath = envPath || DEFAULT_DB_PATH;
+    if (_singletonDb && _singletonDbPath === targetPath) {
+        return _singletonDb;
+    }
+    if (_singletonDb) {
+        try {
+            _singletonDb.close();
+        }
+        catch {
+            /* ignore */
+        }
+        _singletonDb = null;
     }
+    _singletonDb = openSessionDb(targetPath);
+    _singletonDbPath = targetPath;
     return _singletonDb;
 }
 /** Close the singleton connection (call on process exit) */

package/dist/harness/skill-registry.d.ts

@@ -1,6 +1,8 @@
 /**
  * Skills Registry — search and install community skills from a remote registry.
  */
+/** SPDX identifiers for licenses we install without explicit user acceptance. */
+export declare const PERMISSIVE_LICENSES: Set<string>;
 export type RegistrySkill = {
     name: string;
     description: string;
@@ -8,6 +10,14 @@ export type RegistrySkill = {
     version: string;
     source: string;
     tags: string[];
+    /** SPDX license identifier (e.g. "MIT"). Required for new entries; absent for legacy. */
+    license?: string;
+    /** Attribution string to preserve when installing (e.g. "© 2025 Jesse Vincent"). */
+    attribution?: string;
+    /** Upstream homepage / repo URL. */
+    upstream?: string;
+    /** When false, skill cannot be installed via this command — only linked to upstream. Used for viral licenses (CC-BY-SA, GPL). */
+    installable?: boolean;
 };
 export type Registry = {
     skills: RegistrySkill[];
@@ -16,6 +26,20 @@ export type Registry = {
 export declare function fetchRegistry(url?: string): Promise<Registry>;
 /** Search registry by query (matches name, description, tags) */
 export declare function searchRegistry(registry: Registry, query: string): RegistrySkill[];
-/** Install a skill from the registry to ~/.oh/skills/ */
-export declare function installSkill(skill: RegistrySkill): Promise<string>;
+/** Result returned by installSkill — either success with path, or refusal with reason. */
+export type InstallResult = {
+    ok: true;
+    filePath: string;
+} | {
+    ok: false;
+    reason: "not-installable" | "license-not-accepted";
+    message: string;
+};
+/** Install a skill from the registry to ~/.oh/skills/.
+ * Refuses non-permissive licenses unless `acceptLicense` matches the entry's license.
+ * Refuses entries with `installable: false` (e.g. viral-license skills that must be installed upstream).
+ */
+export declare function installSkill(skill: RegistrySkill, opts?: {
+    acceptLicense?: string;
+}): Promise<InstallResult>;
 //# sourceMappingURL=skill-registry.d.ts.map

package/dist/harness/skill-registry.js

@@ -6,6 +6,16 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/zhijiewong/openharness/main/data/registry.json";
 const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
+/** SPDX identifiers for licenses we install without explicit user acceptance. */
+export const PERMISSIVE_LICENSES = new Set([
+    "MIT",
+    "Apache-2.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "ISC",
+    "CC0-1.0",
+    "Unlicense",
+]);
 /** Fetch the registry from remote URL */
 export async function fetchRegistry(url = DEFAULT_REGISTRY_URL) {
     const response = await fetch(url);
@@ -20,16 +30,44 @@ export function searchRegistry(registry, query) {
         s.description.toLowerCase().includes(q) ||
         s.tags.some((t) => t.toLowerCase().includes(q)));
 }
-/** Install a skill from the registry to ~/.oh/skills/ */
-export async function installSkill(skill) {
+/** Install a skill from the registry to ~/.oh/skills/.
+ * Refuses non-permissive licenses unless `acceptLicense` matches the entry's license.
+ * Refuses entries with `installable: false` (e.g. viral-license skills that must be installed upstream).
+ */
+export async function installSkill(skill, opts = {}) {
+    // Gate 1: link-only entries
+    if (skill.installable === false) {
+        const upstream = skill.upstream ? ` Visit ${skill.upstream} to install under its license terms.` : "";
+        return {
+            ok: false,
+            reason: "not-installable",
+            message: `Skill "${skill.name}" is link-only (license: ${skill.license ?? "unknown"}).${upstream}`,
+        };
+    }
+    // Gate 2: license check
+    if (skill.license && !PERMISSIVE_LICENSES.has(skill.license)) {
+        if (opts.acceptLicense !== skill.license) {
+            return {
+                ok: false,
+                reason: "license-not-accepted",
+                message: `Skill "${skill.name}" is licensed under ${skill.license}, which is not in the auto-install allowlist.\n` +
+                    `To install, re-run with --accept-license=${skill.license} to acknowledge its terms.`,
+            };
+        }
+    }
     const response = await fetch(skill.source);
     if (!response.ok)
         throw new Error(`Failed to download skill: ${response.status}`);
-    const content = await response.text();
+    let content = await response.text();
+    // Preserve attribution by prepending an HTML comment if present and not already in the file
+    if (skill.attribution && !content.includes(skill.attribution)) {
+        const header = `<!-- Source: ${skill.upstream ?? skill.source}\n     License: ${skill.license ?? "unknown"}\n     ${skill.attribution} -->\n`;
+        content = header + content;
+    }
     mkdirSync(GLOBAL_SKILLS_DIR, { recursive: true });
     const slug = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
     const filePath = join(GLOBAL_SKILLS_DIR, `${slug}.md`);
     writeFileSync(filePath, content);
-    return filePath;
+    return { ok: true, filePath };
 }
 //# sourceMappingURL=skill-registry.js.map

package/dist/tools/AgentTool/index.d.ts

@@ -13,8 +13,8 @@ declare const inputSchema: z.ZodObject<{
     prompt: string;
     model?: string | undefined;
     description?: string | undefined;
-    isolated?: boolean | undefined;
     isolation?: "worktree" | undefined;
+    isolated?: boolean | undefined;
     run_in_background?: boolean | undefined;
     subagent_type?: string | undefined;
     allowed_tools?: string[] | undefined;
@@ -22,8 +22,8 @@ declare const inputSchema: z.ZodObject<{
     prompt: string;
     model?: string | undefined;
     description?: string | undefined;
-    isolated?: boolean | undefined;
     isolation?: "worktree" | undefined;
+    isolated?: boolean | undefined;
     run_in_background?: boolean | undefined;
     subagent_type?: string | undefined;
     allowed_tools?: string[] | undefined;

package/dist/tools/DiagnosticsTool/index.d.ts

@@ -6,8 +6,8 @@ declare const inputSchema: z.ZodObject<{
     line: z.ZodOptional<z.ZodNumber>;
     character: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    file_path: string;
     action: "diagnostics" | "definition" | "references" | "hover";
+    file_path: string;
     line?: number | undefined;
     character?: number | undefined;
 }, {

package/dist/tools/GrepTool/index.d.ts

@@ -17,30 +17,30 @@ declare const inputSchema: z.ZodObject<{
     "-n": z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     pattern: string;
-    path?: string | undefined;
     type?: string | undefined;
+    "-i"?: boolean | undefined;
+    path?: string | undefined;
+    context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;
-    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;
-    "-i"?: boolean | undefined;
     "-A"?: number | undefined;
     "-B"?: number | undefined;
     "-C"?: number | undefined;
     "-n"?: boolean | undefined;
 }, {
     pattern: string;
-    path?: string | undefined;
     type?: string | undefined;
+    "-i"?: boolean | undefined;
+    path?: string | undefined;
+    context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;
-    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;
-    "-i"?: boolean | undefined;
     "-A"?: number | undefined;
     "-B"?: number | undefined;
     "-C"?: number | undefined;

package/dist/tools/MemoryTool/index.d.ts

@@ -9,20 +9,20 @@ declare const inputSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     global: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    action: "search" | "list" | "save";
+    action: "search" | "save" | "list";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    global?: boolean | undefined;
-    name?: string | undefined;
     description?: string | undefined;
+    name?: string | undefined;
+    global?: boolean | undefined;
     query?: string | undefined;
 }, {
-    action: "search" | "list" | "save";
+    action: "search" | "save" | "list";
     content?: string | undefined;
     type?: "user" | "convention" | "preference" | "project" | "debugging" | "feedback" | "reference" | undefined;
-    global?: boolean | undefined;
-    name?: string | undefined;
     description?: string | undefined;
+    name?: string | undefined;
+    global?: boolean | undefined;
     query?: string | undefined;
 }>;
 export declare const MemoryTool: Tool<typeof inputSchema>;

package/dist/tools/MonitorTool/index.js

@@ -78,7 +78,11 @@ export const MonitorTool = {
                 for (const line of parts)
                     handleLine(line);
             });
-            proc.on("exit", (code) => {
+            // Use "close" rather than "exit": "exit" can fire before stdout data
+            // has been fully drained on fast-exiting commands, causing CI flakiness
+            // where output appears empty. "close" is guaranteed to fire after all
+            // stdio streams have closed.
+            proc.on("close", (code) => {
                 if (!settled) {
                     settled = true;
                     clearTimeout(timer);