@phnx-labs/agents-cli 1.20.71 → 1.20.73

package/dist/lib/project-launch.js

@@ -8,18 +8,12 @@
  *    (+ per-agent symlinks). Delegates to compileRulesForProject, which is
  *    the same helper management-side `agents sync` uses.
  *
- * 2. Mirror project resources from `<cwd>/.agents/{subagents,commands,skills}`
- *    into the agent's workspace-local discovery dirs (`<cwd>/.claude/agents/`,
- *    `<cwd>/.claude/commands/`, `<cwd>/.claude/skills/`). File-level symlinks
- *    so edits in the source dir are live without re-sync. Skips any dest
- *    entry that already exists and isn't one of our symlinks (don't-clobber).
- *    v1: claude-only. Other agents have varying workspace conventions (amp
- *    uses `~/.config/amp`, antigravity uses `~/.gemini/antigravity-cli`,
- *    codex/gemini/cursor lack subagent support entirely) — they're follow-up
- *    material. NOTE: `.mcp.json` is intentionally NOT auto-symlinked from
- *    the launch path — that's a supply-chain surface (cloning a hostile
- *    repo would auto-register an attacker MCP server). Belongs to full
- *    `agents sync` with explicit opt-in, not the hot path.
+ * 2. Copy project resources from `<cwd>/.agents/{commands,skills,subagents,workflows}`
+ *    into the agent's workspace-local discovery dir (`<cwd>/.claude/`,
+ *    `<cwd>/.codex/`, etc.) with an ownership manifest at
+ *    `<cwd>/.{agent}/.agents-managed.json`. The manifest is the only clobber
+ *    authority: paths it lists are removed and refreshed, pre-existing paths it
+ *    does not list are skipped as user-owned.
  *
  * 3. Synthesize four scope-grouped plugin marketplaces under the version's
  *    `<versionHome>/.{agent}/plugins/marketplaces/` (for plugin-capable agents):
@@ -48,8 +42,8 @@ import { supports } from './capabilities.js';
 import { getEnabledExtraRepos, getExtraPluginsDir, getPluginsDir, getProjectAgentsDir, getProjectPluginsDir, getSystemPluginsDir, } from './state.js';
 import { getVersionHomePath } from './versions.js';
 import { toPortableKey } from './platform/index.js';
-import { transformSubagentForClaude } from './subagents.js';
 import { compileRulesForProject } from './rules/compile.js';
+import { syncProjectResourcesToAgent } from './project-resources.js';
 import { discoverPluginsInDir, hasPluginExecSurfaces, inspectPluginCapabilities } from './plugins.js';
 import { MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, addPluginToSettings, copyPluginToMarketplace, marketplaceNameFor, marketplaceRoot, pluginInstallDir, registerMarketplace, removePluginFromSettings, syncMarketplaceManifest, } from './plugin-marketplace.js';
 /**
@@ -77,9 +71,12 @@ export function runLaunchSync(opts) {
         // Don't fail launch on a malformed project rules.yaml.
     }
     // Step 2: workspace resource mirror
-    const mirror = mirrorWorkspaceResources(opts.cwd, opts.agent);
-    result.workspaceLinks = mirror.links;
-    result.workspaceSkipped = mirror.skipped;
+    const projectAgentsDir = getProjectAgentsDir(opts.cwd);
+    if (projectAgentsDir) {
+        const projectResources = syncProjectResourcesToAgent(opts.agent, opts.version, projectAgentsDir);
+        result.workspaceLinks = projectResources.synced.length;
+        result.workspaceSkipped = projectResources.skipped;
+    }
     // Step 3: scoped plugin marketplaces
     result.marketplaces = synthesizeScopedMarketplaces(opts.agent, opts.version, opts.cwd);
     // Touch the shim's skip-fast sentinel. Best-effort — if this fails the
@@ -117,218 +114,6 @@ function touchLaunchSentinel(agent, version, cwd) {
         // best-effort
     }
 }
-const CLAUDE_MIRROR_PLANS = [
-    { srcSubdir: 'subagents', destSubdir: 'agents', mode: 'subagent-write' },
-    { srcSubdir: 'commands', destSubdir: 'commands', mode: 'file-symlink' },
-    { srcSubdir: 'skills', destSubdir: 'skills', mode: 'dir-symlink' },
-];
-/**
- * Marker prepended-as-trailing-comment to every subagent file WE generate.
- * It's an HTML comment — invisible to the markdown the agent reads — placed on
- * the last line so it never disturbs the leading `---` frontmatter block.
- *
- * Ownership rule (the one don't-clobber decision for written, non-symlink
- * files): we only overwrite a `.claude/agents/<name>.md` whose content carries
- * this marker. A user-authored file (no marker) or a symlink at the dest is
- * left untouched. A marker beats an mtime/sidecar sentinel because it travels
- * with the file across copies and git, and needs no out-of-band state.
- */
-const GENERATED_SUBAGENT_MARKER = '<!-- agents-cli:generated-subagent';
-function mirrorWorkspaceResources(cwd, agent) {
-    // v1: claude-only. Other agents have workspace conventions we haven't
-    // mapped (amp: ~/.config/amp; antigravity: ~/.gemini/antigravity-cli;
-    // codex/gemini/cursor: no subagent support per capabilities). Adding them
-    // requires per-agent workspaceDirName + capability gates — follow-up.
-    if (agent !== 'claude')
-        return { links: 0, skipped: [] };
-    const projectAgentsDir = getProjectAgentsDir(cwd);
-    if (!projectAgentsDir)
-        return { links: 0, skipped: [] };
-    const agentWorkspaceDir = path.join(cwd, '.claude');
-    const projectAgentsResolved = (() => {
-        try {
-            return fs.realpathSync(projectAgentsDir);
-        }
-        catch {
-            return path.resolve(projectAgentsDir);
-        }
-    })();
-    let links = 0;
-    const skipped = [];
-    // Mirror subagents / commands / skills. mcp.json is intentionally excluded
-    // — see header doc, it's a supply-chain surface.
-    for (const plan of CLAUDE_MIRROR_PLANS) {
-        const srcDir = path.join(projectAgentsDir, plan.srcSubdir);
-        if (!fs.existsSync(srcDir))
-            continue;
-        const destDir = path.join(agentWorkspaceDir, plan.destSubdir);
-        fs.mkdirSync(destDir, { recursive: true });
-        // Subagents flatten N source files into one written .md — not a symlink.
-        if (plan.mode === 'subagent-write') {
-            const r = writeProjectSubagents(srcDir, destDir, cwd);
-            links += r.links;
-            skipped.push(...r.skipped);
-            continue;
-        }
-        const entries = fs.readdirSync(srcDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith('.'))
-                continue;
-            if (plan.mode === 'dir-symlink' && !entry.isDirectory())
-                continue;
-            if (plan.mode === 'file-symlink' && !entry.isFile() && !entry.isSymbolicLink())
-                continue;
-            const srcPath = path.join(srcDir, entry.name);
-            const destPath = path.join(destDir, entry.name);
-            if (replaceWithSymlinkIfOwned(srcPath, destPath, projectAgentsResolved)) {
-                links += 1;
-            }
-            else {
-                skipped.push(path.relative(cwd, destPath));
-            }
-        }
-    }
-    return { links, skipped };
-}
-/**
- * Mirror project subagents into `<cwd>/.claude/agents/`. The canonical source
- * shape is a DIRECTORY containing AGENT.md (e.g. `.agents/subagents/probe/AGENT.md`)
- * — confirmed by the detector (versions.ts) and lister (subagents.ts). Each
- * such directory is flattened via transformSubagentForClaude (the exact writer
- * the version-home sync uses) into a single `<name>.md`, then written under an
- * ownership marker so a re-launch refreshes our file but never clobbers a
- * user-authored one.
- *
- * Returns the same {links, skipped} shape the symlink path reports, so the
- * caller's accounting is uniform across resource kinds.
- */
-function writeProjectSubagents(srcDir, destDir, cwd) {
-    let links = 0;
-    const skipped = [];
-    for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-        if (entry.name.startsWith('.'))
-            continue;
-        if (!entry.isDirectory())
-            continue;
-        const subagentDir = path.join(srcDir, entry.name);
-        if (!fs.existsSync(path.join(subagentDir, 'AGENT.md')))
-            continue;
-        const destPath = path.join(destDir, `${entry.name}.md`);
-        if (writeSubagentIfOwned(subagentDir, destPath)) {
-            links += 1;
-        }
-        else {
-            skipped.push(path.relative(cwd, destPath));
-        }
-    }
-    return { links, skipped };
-}
-/**
- * Write a flattened subagent file at `destPath`, refusing to clobber user state.
- *
- *   - dest missing            → write fresh.
- *   - dest is our generation  → overwrite (refresh; carries GENERATED_SUBAGENT_MARKER).
- *   - dest is a symlink / any
- *     non-regular file         → SKIP (user state we don't own).
- *   - dest is a regular file
- *     without our marker        → SKIP (hand-authored .claude/agents/<name>.md).
- *
- * Returns true when our file is present (written now or already current),
- * false when we left a user-owned dest alone.
- */
-function writeSubagentIfOwned(subagentDir, destPath) {
-    let existing = null;
-    let destLstat = null;
-    try {
-        destLstat = fs.lstatSync(destPath);
-    }
-    catch { /* missing — write fresh */ }
-    if (destLstat) {
-        if (!destLstat.isFile())
-            return false; // symlink/dir/etc. — user state
-        try {
-            existing = fs.readFileSync(destPath, 'utf-8');
-        }
-        catch {
-            return false;
-        }
-        if (!existing.includes(GENERATED_SUBAGENT_MARKER))
-            return false; // hand-authored
-    }
-    let body;
-    try {
-        body = transformSubagentForClaude(subagentDir);
-    }
-    catch {
-        return false; // malformed AGENT.md — don't write a broken file
-    }
-    const content = `${body}\n\n${GENERATED_SUBAGENT_MARKER} — edit .agents/subagents/${path.basename(subagentDir)}/ instead -->\n`;
-    // Skip-fast: identical content already on disk → no write (keeps mtime stable).
-    if (existing === content)
-        return true;
-    try {
-        fs.mkdirSync(path.dirname(destPath), { recursive: true });
-        fs.writeFileSync(destPath, content);
-    }
-    catch {
-        return false;
-    }
-    return true;
-}
-/**
- * Create or refresh a symlink at `destPath` pointing at `srcPath`. Returns
- * true if we wrote (or already had) the link, false if we skipped because
- * the destination is user-owned (regular file, directory, or symlink pointing
- * outside the project's `.agents/` tree, or a dangling symlink — treated as
- * user state we don't yet understand).
- *
- * Skip-fast: if the destination is already a symlink resolving to the
- * project-agents tree AND its target matches srcPath, no write happens.
- */
-function replaceWithSymlinkIfOwned(srcPath, destPath, projectAgentsResolved) {
-    let destLstat = null;
-    try {
-        destLstat = fs.lstatSync(destPath);
-    }
-    catch { /* missing — write fresh */ }
-    if (destLstat) {
-        if (!destLstat.isSymbolicLink()) {
-            return false;
-        }
-        let destTargetReal = null;
-        try {
-            destTargetReal = fs.realpathSync(destPath);
-        }
-        catch { /* dangling */ }
-        // Dangling symlink → user-owned in-progress state; do not clobber.
-        if (destTargetReal === null) {
-            return false;
-        }
-        if (destTargetReal !== projectAgentsResolved && !destTargetReal.startsWith(projectAgentsResolved + path.sep)) {
-            return false;
-        }
-        let srcReal = null;
-        try {
-            srcReal = fs.realpathSync(srcPath);
-        }
-        catch { /* src vanished mid-launch */ }
-        if (srcReal !== null && destTargetReal === srcReal) {
-            return true; // already correct
-        }
-        try {
-            fs.unlinkSync(destPath);
-        }
-        catch { /* ignore */ }
-    }
-    try {
-        fs.mkdirSync(path.dirname(destPath), { recursive: true });
-        fs.symlinkSync(srcPath, destPath);
-    }
-    catch {
-        return false;
-    }
-    return true;
-}
 function makeScope(spec, pluginsDir, autoEnableExecSurfaces, precedence) {
     return { spec, marketplaceName: marketplaceNameFor(spec), pluginsDir, autoEnableExecSurfaces, precedence };
 }

package/dist/lib/project-resources.d.ts

@@ -0,0 +1,7 @@
+import type { AgentId } from './types.js';
+export interface ProjectResourceSyncResult {
+    synced: string[];
+    skipped: string[];
+}
+export declare function projectAgentRoot(projectRoot: string, agent: AgentId): string;
+export declare function syncProjectResourcesToAgent(agent: AgentId, version: string, projectAgentsDir: string): ProjectResourceSyncResult;

package/dist/lib/project-resources.js

@@ -0,0 +1,291 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS, agentConfigDirName } from './agents.js';
+import { supports } from './capabilities.js';
+import { buildCommandSkillContent, commandSkillName, readSkillSourceCommandMarker, shouldInstallCommandAsSkill } from './command-skills.js';
+import { commandAppliesTo, parseCommandMetadata } from './commands.js';
+import { markdownToToml } from './convert.js';
+import { safeJoin } from './paths.js';
+import { subagentTarget } from './subagents-registry.js';
+import { parseSubagentFrontmatter } from './subagents.js';
+import { syncWorkflowToVersion } from './workflows.js';
+const MANIFEST_FILE = '.agents-managed.json';
+const MANIFEST_VERSION = 1;
+const COPY_IGNORE = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
+export function projectAgentRoot(projectRoot, agent) {
+    return path.join(projectRoot, agentConfigDirName(agent));
+}
+export function syncProjectResourcesToAgent(agent, version, projectAgentsDir) {
+    const projectRoot = path.dirname(projectAgentsDir);
+    const agentRoot = projectAgentRoot(projectRoot, agent);
+    const manifest = loadProjectManifest(agentRoot);
+    const result = { synced: [], skipped: [] };
+    const next = new Set();
+    if (manifest) {
+        for (const rel of manifest.paths)
+            removeManagedPath(agentRoot, rel);
+    }
+    syncProjectCommands(agent, version, projectAgentsDir, agentRoot, result, next);
+    syncProjectSkills(agent, version, projectAgentsDir, agentRoot, result, next);
+    syncProjectSubagents(agent, version, projectAgentsDir, projectRoot, agentRoot, manifest, result, next);
+    syncProjectWorkflows(agent, version, projectAgentsDir, projectRoot, agentRoot, result, next);
+    if (next.size > 0 || manifest) {
+        writeProjectManifest(agentRoot, Array.from(next).sort());
+    }
+    return result;
+}
+function loadProjectManifest(agentRoot) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(agentRoot, MANIFEST_FILE), 'utf-8'));
+        if (raw.v !== MANIFEST_VERSION || !Array.isArray(raw.paths))
+            return null;
+        if (!raw.paths.every((p) => typeof p === 'string' && p.length > 0))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeProjectManifest(agentRoot, paths) {
+    fs.mkdirSync(agentRoot, { recursive: true });
+    const p = path.join(agentRoot, MANIFEST_FILE);
+    const tmp = p + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify({ v: MANIFEST_VERSION, paths }, null, 2));
+    fs.renameSync(tmp, p);
+}
+function removeManagedPath(agentRoot, rel) {
+    if (path.isAbsolute(rel) || rel.includes('..'))
+        return;
+    const target = path.resolve(agentRoot, rel);
+    const root = path.resolve(agentRoot);
+    if (target !== root && !target.startsWith(root + path.sep))
+        return;
+    removePath(target);
+}
+function removePath(p) {
+    try {
+        const st = fs.lstatSync(p);
+        if (st.isSymbolicLink() || st.isFile())
+            fs.unlinkSync(p);
+        else if (st.isDirectory())
+            fs.rmSync(p, { recursive: true, force: true });
+    }
+    catch {
+        // already absent
+    }
+}
+function pathExists(p) {
+    try {
+        fs.lstatSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function copyDir(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (entry.isSymbolicLink() || COPY_IGNORE.has(entry.name))
+            continue;
+        const s = safeJoin(src, entry.name);
+        const d = safeJoin(dest, entry.name);
+        if (entry.isDirectory())
+            copyDir(s, d);
+        else if (entry.isFile())
+            fs.copyFileSync(s, d);
+    }
+}
+function projectEntries(projectAgentsDir, kind) {
+    const dir = path.join(projectAgentsDir, kind);
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+}
+function record(kind, name, relPaths, result, manifestPaths) {
+    result.synced.push(`${kind}/${name}`);
+    for (const rel of relPaths)
+        manifestPaths.add(rel);
+}
+function skip(dest, projectRoot, result) {
+    const rel = path.relative(projectRoot, dest);
+    result.skipped.push(rel);
+    console.warn(`Skipping project resource target ${rel}: already exists and is user-owned`);
+}
+function syncProjectCommands(agent, version, projectAgentsDir, agentRoot, result, manifestPaths) {
+    const cfg = AGENTS[agent];
+    const commandsAsSkills = shouldInstallCommandAsSkill(agent, version);
+    const supportsCommands = supports(agent, 'commands', version).ok;
+    if (!commandsAsSkills && !supportsCommands)
+        return;
+    const projectRoot = path.dirname(projectAgentsDir);
+    for (const entry of projectEntries(projectAgentsDir, 'commands')) {
+        if (!entry.isFile() || !entry.name.endsWith('.md'))
+            continue;
+        const name = entry.name.slice(0, -'.md'.length);
+        const srcFile = path.join(projectAgentsDir, 'commands', entry.name);
+        const metadata = parseCommandMetadata(srcFile);
+        if (!commandAppliesTo(agent, version, metadata).ok)
+            continue;
+        if (commandsAsSkills) {
+            const sourceMarker = readSkillSourceCommandMarker(name, [path.join(projectAgentsDir, 'skills')]);
+            if (pathExists(path.join(projectAgentsDir, 'skills', name)) && sourceMarker !== name)
+                continue;
+            const skillName = commandSkillName(name);
+            const rel = path.join('skills', skillName);
+            const destDir = path.join(agentRoot, rel);
+            if (pathExists(destDir)) {
+                skip(destDir, projectRoot, result);
+                continue;
+            }
+            fs.mkdirSync(destDir, { recursive: true });
+            fs.writeFileSync(path.join(destDir, 'SKILL.md'), buildCommandSkillContent(name, srcFile), 'utf-8');
+            record('commands', name, [rel], result, manifestPaths);
+            continue;
+        }
+        const ext = cfg.format === 'toml' ? '.toml' : '.md';
+        const rel = path.join(cfg.commandsSubdir, `${name}${ext}`);
+        const destFile = path.join(agentRoot, rel);
+        if (pathExists(destFile)) {
+            skip(destFile, projectRoot, result);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(destFile), { recursive: true });
+        if (cfg.format === 'toml') {
+            fs.writeFileSync(destFile, markdownToToml(name, fs.readFileSync(srcFile, 'utf-8')), 'utf-8');
+        }
+        else {
+            fs.copyFileSync(srcFile, destFile);
+        }
+        record('commands', name, [rel], result, manifestPaths);
+    }
+}
+function syncProjectSkills(agent, version, projectAgentsDir, agentRoot, result, manifestPaths) {
+    if (!supports(agent, 'skills', version).ok)
+        return;
+    const projectRoot = path.dirname(projectAgentsDir);
+    for (const entry of projectEntries(projectAgentsDir, 'skills')) {
+        if (!entry.isDirectory())
+            continue;
+        const srcDir = path.join(projectAgentsDir, 'skills', entry.name);
+        if (!fs.existsSync(path.join(srcDir, 'SKILL.md')))
+            continue;
+        const rel = path.join('skills', entry.name);
+        const destDir = path.join(agentRoot, rel);
+        if (pathExists(destDir)) {
+            skip(destDir, projectRoot, result);
+            continue;
+        }
+        copyDir(srcDir, destDir);
+        record('skills', entry.name, [rel], result, manifestPaths);
+    }
+}
+function readProjectSubagents(projectAgentsDir) {
+    const map = new Map();
+    for (const entry of projectEntries(projectAgentsDir, 'subagents')) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(projectAgentsDir, 'subagents', entry.name);
+        const agentMd = path.join(dir, 'AGENT.md');
+        if (!fs.existsSync(agentMd))
+            continue;
+        const frontmatter = parseSubagentFrontmatter(agentMd);
+        if (!frontmatter)
+            continue;
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md')).sort();
+        map.set(entry.name, { name: entry.name, path: dir, files, frontmatter });
+    }
+    return map;
+}
+function syncProjectSubagents(agent, version, projectAgentsDir, projectRoot, agentRoot, manifest, result, manifestPaths) {
+    if (!supports(agent, 'subagents', version).ok)
+        return;
+    const target = subagentTarget(agent);
+    if (!target)
+        return;
+    const all = readProjectSubagents(projectAgentsDir);
+    const dir = target.dir(projectRoot);
+    const targetDirRel = path.relative(agentRoot, dir);
+    const hadManagedTarget = manifest?.paths.some((rel) => rel === targetDirRel || rel.startsWith(targetDirRel + path.sep)) ?? false;
+    for (const sub of all.values()) {
+        const occupied = target.occupied(dir, sub.name);
+        const existing = occupied.find((entry) => pathExists(entry.path));
+        if (existing) {
+            skip(existing.path, projectRoot, result);
+            continue;
+        }
+        try {
+            target.write(dir, sub);
+            record('subagents', sub.name, occupied.map((entry) => path.relative(agentRoot, entry.path)), result, manifestPaths);
+        }
+        catch {
+            // Malformed source or unsupported transform; skip this item.
+        }
+    }
+    const syncedNames = result.synced
+        .filter((name) => name.startsWith('subagents/'))
+        .map((name) => name.slice('subagents/'.length))
+        .filter((name) => all.has(name))
+        .map((name) => all.get(name));
+    if (target.finalize && (syncedNames.length > 0 || hadManagedTarget)) {
+        target.finalize(dir, syncedNames);
+        for (const entry of target.finalizeOccupied?.(dir) ?? []) {
+            manifestPaths.add(path.relative(agentRoot, entry.path));
+        }
+    }
+}
+function workflowManagedRelPaths(agent, projectRoot, name, workflowDir) {
+    if (agent === 'kimi')
+        return [path.join('.kimi-code', 'skills', name)];
+    if (agent === 'goose') {
+        const rels = [path.join('.config', 'goose', 'recipes', `${name}.yaml`)];
+        const subagentsDir = path.join(workflowDir, 'subagents');
+        let hasSubagents = false;
+        try {
+            hasSubagents = fs.readdirSync(subagentsDir).some((f) => f.endsWith('.md'));
+        }
+        catch {
+            hasSubagents = false;
+        }
+        if (hasSubagents)
+            rels.push(path.join('.config', 'goose', 'recipes', `${name}.subrecipes`));
+        return rels;
+    }
+    if (agent === 'openclaw')
+        return [path.join('.openclaw', 'workflows', `${name}.lobster`)];
+    return [path.join(agentConfigDirName(agent), 'workflows', name)];
+}
+function syncProjectWorkflows(agent, version, projectAgentsDir, projectRoot, agentRoot, result, manifestPaths) {
+    if (!supports(agent, 'workflows', version).ok)
+        return;
+    if (agent === 'antigravity')
+        return;
+    for (const entry of projectEntries(projectAgentsDir, 'workflows')) {
+        if (!entry.isDirectory())
+            continue;
+        const workflowDir = path.join(projectAgentsDir, 'workflows', entry.name);
+        if (!fs.existsSync(path.join(workflowDir, 'WORKFLOW.md')))
+            continue;
+        const rels = workflowManagedRelPaths(agent, projectRoot, entry.name, workflowDir);
+        const existing = rels.map((rel) => path.join(projectRoot, rel)).find((dest) => pathExists(dest));
+        if (existing) {
+            skip(existing, projectRoot, result);
+            continue;
+        }
+        let success = false;
+        if (agent === 'kimi' || agent === 'goose' || agent === 'openclaw') {
+            success = syncWorkflowToVersion(workflowDir, entry.name, agent, projectRoot).success;
+        }
+        else {
+            copyDir(workflowDir, path.join(agentRoot, 'workflows', entry.name));
+            success = true;
+        }
+        if (success) {
+            record('workflows', entry.name, rels.map((rel) => path.relative(agentRoot, path.join(projectRoot, rel))), result, manifestPaths);
+        }
+    }
+}

package/dist/lib/pty-client.d.ts

@@ -4,6 +4,14 @@
  * Thin client that connects to the PTY sidecar server over unix socket.
  * Each call opens a connection, sends a JSON request, reads the JSON response, and closes.
  */
+export interface ServerSpawnArgs {
+    bin: string;
+    args: string[];
+}
+export interface ServerExit {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+}
 /** JSON response envelope from the PTY server. */
 export interface PtyResponse {
     ok: boolean;
@@ -15,6 +23,25 @@ export interface PtyResponse {
  * Auto-starts the server if not running.
  */
 export declare function ptyRequest(action: string, id?: string, params?: Record<string, any>): Promise<PtyResponse>;
+export declare function getServerSpawnArgs(options?: {
+    isStandaloneExecutable?: boolean;
+    /** Physical binary path (test seam). Defaults to `process.execPath`. */
+    execPath?: string;
+    /** Locate a real `node` (test seam). Defaults to `which/where node`. */
+    resolveNode?: () => string | undefined;
+    /** File-existence check (test seam). Defaults to `fs.existsSync`. */
+    fileExists?: (p: string) => boolean;
+}): ServerSpawnArgs;
+export declare function isBunStandaloneExecutable(moduleUrl?: string): boolean;
+export declare function readRecentLogLines(logPath: string, maxLines?: number): string[];
+export declare function buildPtyStartFailureMessage(details: {
+    timeoutMs: number;
+    spawn: ServerSpawnArgs;
+    exit?: ServerExit;
+    spawnError?: Error;
+    lastReadinessError?: Error;
+    logPath: string;
+}): string;
 /**
  * Parse escape sequences in user input strings.
  * Handles: \n \r \t \e \xHH \\