devlyn-cli 4.3.28 → 4.3.30

package/bin/harness-activation.js

@@ -8,9 +8,14 @@ const history = require('./skill-history.json');
 const { MARKER, marketplaceName, projectionPath, inspectProjection } = require('./codex-projection');
 
 const SKILLS = ['devlyn-ideate', 'devlyn-engines'];
+// The version an engine's run-folder channel was examined on; bin/engines.js keeps the engine's floor. An
+// older version, and Windows (channelGate), keep the plan they had before the channel: only a first task
+// carries the principles.
+const CHANNEL_MINIMUM = { antigravity: '1.5.4', cursor: '2026.11.05-86047df' };
 const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 const textValue = (value) => typeof value === 'string' && !value.includes('\0');
 const strings = (value) => Array.isArray(value) && value.every(textValue);
+const isFile = (file) => fs.statSync(file, { throwIfNoEntry: false })?.isFile() === true;
 const reason = (code, params = {}) => ({ code, params });
 const channel = (state = 'disabled', mechanism = null, reasons = []) => ({ state, mechanism, reasons });
 const joinText = (...parts) => parts.filter((part) => part !== null && part !== undefined && part !== '').join('\n\n');
@@ -90,6 +95,7 @@ function effectiveConfig(context) {
     claude: ['appendSystemPrompt', 'pluginDirs'], codex: ['developer_instructions', 'skills', 'marketplaces', 'plugins'],
     grok: ['rules'], omp: ['appendSystemPrompt', 'skills'], antigravity: [], cursor: [],
     opencode: ['inlineConfig', 'skillsPaths'], kimi: ['ownerAgent'], copilot: ['skillsDirs', 'instructionsDirs'], qwen: ['appendSystemPrompt'],
+    pi: ['appendSystemPrompt'],
   }[context.engine];
   if (!object(config) || Object.keys(config).some((key) => !keys.includes(key))) return null;
   for (const field of ['appendSystemPrompt', 'developer_instructions', 'rules', 'inlineConfig', 'skillsDirs', 'instructionsDirs']) {
@@ -120,11 +126,27 @@ function effectiveConfig(context) {
   return config;
 }
 
+// pi's agent dir is PI_CODING_AGENT_DIR, else ~/.pi/agent. That ~, and a leading ~ pi expands in the
+// variable, is os.homedir(): USERPROFILE on Windows, HOME elsewhere (config.js getAgentDir). The home of
+// its user .agents/skills takes HOME first on every platform (package-manager.js getHomeDir).
+function piFolders(cwd, env, platform = process.platform) {
+  const paths = platform === 'win32' ? path.win32 : path.posix;
+  const home = (platform === 'win32' ? env.USERPROFILE : env.HOME) || os.homedir();
+  const dir = env.PI_CODING_AGENT_DIR;
+  const agentDir = dir ? dir.replace(platform === 'win32' ? /^~(?=$|[\\/])/ : /^~(?=$|\/)/, () => home) : paths.join(home, '.pi', 'agent');
+  return { agentDir: paths.resolve(cwd, agentDir), agentsHome: env.HOME || home };
+}
+
 function discoveryRoots(context, env, config) {
   const home = env.HOME || env.USERPROFILE || os.homedir();
+  const pi = piFolders(context.cwd, env);
   const roots = [...(context.skillRoots || [])];
   const add = (base, ...parts) => { if (base) roots.push(path.resolve(base, ...parts)); };
   const engine = context.engine;
+  // Antigravity and Cursor search the folders their examined version reads only where they get their run-folder
+  // channel; elsewhere they keep the folders searched before it.
+  const channelled = ['antigravity', 'cursor'].includes(engine) && !channelGate(context);
+  const antigravity = channelled && engine === 'antigravity';
   const native = {
     claude: [env.CLAUDE_CONFIG_DIR || path.join(home, '.claude'), '.claude'],
     codex: [context.accountHome || env.CODEX_HOME || path.join(home, '.codex'), '.agents'],
@@ -135,10 +157,13 @@ function discoveryRoots(context, env, config) {
     kimi: [env.KIMI_CODE_HOME || path.join(home, '.kimi-code'), '.kimi-code'],
     copilot: [env.COPILOT_HOME || path.join(home, '.copilot'), '.github'],
     qwen: [env.QWEN_HOME || path.join(home, '.qwen'), '.qwen'],
+    pi: [pi.agentDir, null],
   }[engine];
   if (engine !== 'codex') add(native[0], 'skills');
   const copilotDefaultHome = !env.COPILOT_HOME || path.resolve(env.COPILOT_HOME) === path.join(home, '.copilot');
-  if (!['claude', 'cursor'].includes(engine) && (engine !== 'copilot' || copilotDefaultHome)) add(home, '.agents/skills');
+  if (!['claude', 'cursor'].includes(engine) && !antigravity && (engine !== 'copilot' || copilotDefaultHome)) add(engine === 'pi' ? pi.agentsHome : home, '.agents/skills');
+  // The examined Antigravity reads ~/.gemini/skills and its personal folder ~/.gemini/config instead.
+  if (antigravity) { add(home, '.gemini/skills'); add(home, '.gemini/config/skills'); }
   if (['omp', 'opencode', 'grok'].includes(engine)) add(home, '.claude/skills');
   if (engine === 'omp') {
     add(home, '.codex/skills'); add(home, '.agent/skills');
@@ -150,12 +175,25 @@ function discoveryRoots(context, env, config) {
     for (const dir of config?.skillsPaths || []) add(context.cwd, dir);
   }
   if (engine === 'copilot') for (const dir of (config?.skillsDirs ?? env.COPILOT_SKILLS_DIRS ?? '').split(',').filter(Boolean)) add(context.cwd, dir);
+  if (engine === 'pi') add(context.cwd, '.pi/skills');
+  const walk = [];
   for (let dir = path.resolve(context.cwd); ; dir = path.dirname(dir)) {
+    walk.push(dir);
+    if (fs.existsSync(path.join(dir, '.git'))) break;
+    // Outside any repository the examined Antigravity reads the working directory alone.
+    if (dir === path.dirname(dir)) { if (antigravity) walk.splice(1); break; }
+  }
+  // The examined Cursor also searches nested folders below the working directory, which the planner does not.
+  const cursorFolders = channelled && engine === 'cursor' ? ['.cursor', '.agents', '.claude', '.codex', '.grok'] : [];
+  for (const folder of cursorFolders) add(home, folder, 'skills');
+  if (cursorFolders.length) add(home, '.cursor/skills-cursor');
+  for (const dir of walk) {
+    for (const folder of cursorFolders) add(dir, folder, 'skills');
     if (native[1]) add(dir, native[1], 'skills');
     if (!['claude', 'cursor'].includes(engine)) add(dir, '.agents/skills');
     if (['grok', 'omp', 'opencode', 'copilot'].includes(engine)) add(dir, '.claude/skills');
     if (['omp', 'antigravity'].includes(engine)) add(dir, '.agent/skills');
-    if (fs.existsSync(path.join(dir, '.git')) || dir === path.dirname(dir)) break;
+    if (antigravity) { add(dir, '_agents/skills'); add(dir, '_agent/skills'); }
   }
   return [...new Set(roots)];
 }
@@ -187,6 +225,153 @@ function kimiSkillRoots(context, env) {
   return { roots: [...roots], errors };
 }
 
+// omp and pi read their own APPEND_SYSTEM.md only when no append text is passed, and the plan passes
+// some, so the owner's text leads it. Text the caller supplies wins, an explicit empty string included.
+// Only when it supplies none (the key absent, or null for unset) is the first existing file `lookup()`
+// names read, as `devlyn run` reads omp's (harness-context.js ompOwnerAppend). Returns {text}, or
+// {reason} when the owner's text cannot be known.
+function ownerAppend(config, lookup) {
+  if (config.appendSystemPrompt != null) return { text: config.appendSystemPrompt };
+  try {
+    const found = lookup();
+    if (found.reason) return found;
+    const file = found.files.find(isFile);
+    return { text: file === undefined ? null : fs.readFileSync(file, 'utf8') };
+  } catch (error) {
+    return { reason: reason('config-unreadable', { path: error.path, detail: error.code || error.message }) };
+  }
+}
+
+// pi's user and project settings.json (settings-manager.js). Entries they name resolve through pi's own
+// package manager, which the planner does not repeat. A file that cannot be read is null and reported.
+function piSettings(cwd, agentDir) {
+  const settings = { errors: [] };
+  for (const [scope, file] of [['user', path.join(agentDir, 'settings.json')], ['project', path.join(cwd, '.pi/settings.json')]]) {
+    try {
+      settings[scope] = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '') || '{}') : {};
+    } catch (error) {
+      settings[scope] = null;
+      settings.errors.push(reason('config-unreadable', { path: file, detail: error.code || error.message }));
+    }
+  }
+  return settings;
+}
+const listed = (settings, ...keys) => keys.some((key) => settings?.[key] != null && settings[key].length !== 0);
+
+// Whether the agent dir's extensions folder holds anything pi could load; pi skips dot entries and
+// node_modules (package-manager.js collectAutoExtensionEntries).
+function piExtensionEntries(agentDir) {
+  try {
+    return fs.readdirSync(path.join(agentDir, 'extensions')).some((name) => !name.startsWith('.') && name !== 'node_modules');
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+// pi reads a project's .pi/APPEND_SYSTEM.md only when it trusts the project, else its agent dir's
+// (resource-loader discoverAppendSystemPromptFile). pi first asks the extensions it loads before trust,
+// and the first yes or no wins (project-trust.js resolveProjectTrusted). With project settings held
+// untrusted, those come only from the agent dir's extensions folder and the extensions or packages its
+// user settings name (resource-loader loadProjectTrustExtensions, package-manager resolve): the app
+// passes no -e, and pi's built-in extensions answer no trust question. With none, trust is pi's saved
+// decision for the folder or its nearest decided parent (trust.json). Otherwise pi settles trust at
+// launch, so which file it reads cannot be known here. The planner never writes trust.
+function piAppendFiles(cwd, agentDir, userSettings) {
+  const project = path.join(cwd, '.pi/APPEND_SYSTEM.md');
+  const user = path.join(agentDir, 'APPEND_SYSTEM.md');
+  if (!isFile(project)) return { files: [user] };
+  const undecided = { reason: reason('principles-unavailable', { detail: 'project-trust-undecided', path: project }) };
+  if (userSettings === null || listed(userSettings, 'extensions', 'packages') || piExtensionEntries(agentDir)) return undecided;
+  const store = path.join(agentDir, 'trust.json');
+  let trusted = null;
+  try {
+    const saved = fs.existsSync(store) ? JSON.parse(fs.readFileSync(store, 'utf8').replace(/^\uFEFF/, '')) : {};
+    if (!object(saved) || Object.values(saved).some((value) => ![true, false, null].includes(value))) throw new Error('not a trust record');
+    for (let dir = fs.realpathSync(cwd); trusted === null; dir = path.dirname(dir)) {
+      if (typeof saved[dir] === 'boolean') trusted = saved[dir];
+      else if (dir === path.dirname(dir)) break;
+    }
+  } catch (error) {
+    return { reason: reason('config-unreadable', { path: store, detail: error.code || error.message }) };
+  }
+  if (trusted === null) return undecided;
+  return { files: [trusted ? project : user] };
+}
+
+// The files pi may load as skills below a root (package-manager.js collectSkillEntries). pi stops at a
+// folder's SKILL.md unless an ignore file hides it, and takes other .md files at the root of its own
+// folders and below it in .agents/skills. Ignore files are not read here, so every .md file is taken and
+// every folder searched: at least what pi finds is found. Dot entries and node_modules are skipped as pi
+// skips them.
+function piSkillFiles(root) {
+  const files = [], seen = new Set();
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (error) {
+      if (dir === root && error.code === 'ENOENT') return;
+      throw error;
+    }
+    seen.add(fs.realpathSync(dir));
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const full = path.join(dir, entry.name);
+      let kind = entry;
+      // pi follows links and skips one it cannot follow.
+      if (entry.isSymbolicLink()) { try { kind = fs.statSync(full); } catch { continue; } }
+      if (kind.isDirectory()) { if (!seen.has(fs.realpathSync(full))) visit(full); }
+      else if (kind.isFile() && entry.name.endsWith('.md')) files.push(full);
+    }
+  };
+  visit(root);
+  return files;
+}
+
+// The names pi may give a skill file (skills.js loadSkillFromFile): its frontmatter's string `name`, else,
+// also for an empty one, its folder's name. A plain scalar may be no string (null, a number), so the
+// folder counts then too.
+// null when the name is not one simple line, which counts as a collision.
+function piSkillNames(file) {
+  const text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n');
+  const folder = path.basename(path.dirname(file));
+  const end = text.startsWith('---') ? text.indexOf('\n---', 3) : -1;
+  const lines = end < 0 ? [] : text.slice(4, end).split('\n');
+  if (/^\s/.test(lines.find((line) => line.trim() && !line.trim().startsWith('#')) ?? '')) return null;
+  // Lines that are or may be a top-level name key: quoted or complex keys, merges, anchors, flow mappings.
+  const keys = lines.flatMap((line, index) => (/^(?:name[ \t]*:|["'?{[&*!]|<<)/.test(line) ? [index] : []));
+  if (!keys.length) return [folder];
+  const match = keys.length === 1 && /^name:(.*)$/.exec(lines[keys[0]]);
+  if (!match) return null;
+  const value = match[1].replace(/\s#.*$/, '').trim();
+  const quoted = /^"([^"\\]*)"$|^'([^']*)'$/.exec(value);
+  if (quoted) return [(quoted[1] ?? quoted[2]) || folder];
+  const next = lines.slice(keys[0] + 1).find((line) => line.trim()) ?? '';
+  if (!value || /^[-?:,[\]{}#&*!|>'"%@`]/.test(value) || /^\s/.test(next)) return null;
+  return [value, folder];
+}
+
+// pi names a skill by its frontmatter wherever it sits below a root, and a found name wins over --skill.
+// Files `found` already reports are skipped.
+function piNameCollisions(roots, found) {
+  const collisions = [], errors = [], seen = new Set(found.map((entry) => entry.path));
+  for (const root of roots) {
+    try {
+      for (const file of piSkillFiles(root)) {
+        if (seen.has(file)) continue;
+        seen.add(file);
+        const names = piSkillNames(file);
+        if (names === null) collisions.push(reason('name-collision', { path: file }));
+        else for (const name of new Set(names)) if (SKILLS.includes(name)) collisions.push(reason('name-collision', { name, path: file }));
+      }
+    } catch (error) {
+      errors.push(reason('config-unreadable', { path: error.path || root, detail: error.code || error.message }));
+    }
+  }
+  return { collisions, errors };
+}
+
 function inspectSkills(context, release, env, config, active) {
   const found = [], errors = [], hashes = new Map();
   for (const root of discoveryRoots(context, env, config)) {
@@ -214,10 +399,73 @@ function skillCatalog(release, paths = path) {
   return ['Devlyn session skill catalog (read the absolute file to invoke):',
     ...SKILLS.map((name) => `${name}: ${paths.join(root, name, 'SKILL.md')}`),
     `This session's _shared folder is ${paths.join(root, '_shared')}.`,
-    'Use that absolute folder wherever the Devlyn defaults name _shared/, including the Quick Start references to .claude/skills/ or .agents/skills/.',
+    'Use that absolute folder wherever the Devlyn defaults name _shared/.',
   ].join('\n');
 }
 
+// A skill entry of Antigravity's run folder: the release skill's own name and description lines as
+// written, then the release SKILL.md to follow. A copy cannot be planned (plan files are text and the
+// skills carry scripts), and since 1.5.2 Antigravity skips a link or a manifest entry that leads outside
+// the added folder. Each line must be one complete top-level entry, or the plan fails.
+function antigravitySkill(release, name) {
+  const dir = path.join(release.root, 'config/skills', name);
+  const file = path.join(dir, 'SKILL.md');
+  const text = fs.readFileSync(file, 'utf8').replace(/\r\n/g, '\n');
+  const end = text.startsWith('---\n') ? text.indexOf('\n---\n', 3) : -1;
+  const lines = end < 0 ? [] : text.slice(4, end).split('\n');
+  const header = ['name', 'description'].map((field) => {
+    const at = lines.flatMap((line, index) => (line.startsWith(`${field}:`) ? [index] : []));
+    if (at.length !== 1 || !lines[at[0]].slice(field.length + 1).trim() || /^\s/.test(lines[at[0] + 1] ?? '')) {
+      fail('config-unreadable', { path: file, field }, 1);
+    }
+    return lines[at[0]];
+  });
+  return `---\n${header.join('\n')}\n---\nRead ${file} and follow it as this skill. `
+    + `Its folder, ${dir}, is the skill's folder (DEVLYN_SKILL_DIR), not the folder of this file.\n`;
+}
+
+// The path with the links of its existing part resolved; parts that do not exist yet are kept as given.
+function physicalPath(target) {
+  let parent = path.resolve(target);
+  const missing = [];
+  while (!fs.existsSync(parent)) { missing.unshift(path.basename(parent)); parent = path.dirname(parent); }
+  return path.join(fs.realpathSync(parent), ...missing);
+}
+
+// The reasons for the principles and the skills when neither reaches the session.
+const withheld = (params) => [reason('principles-unavailable', params), reason('skills-unavailable', params)];
+
+// Why an engine keeps the plan it had before its run-folder channel, as the reasons for the principles and the
+// skills when no first task carries them, or null when it gets the channel. The channels were examined on macOS
+// and are not planned on Windows, whatever the version: it cannot show who owns a folder, and an argument that
+// misbehaves there would break a pane. Below the version a channel was examined on, updating the engine gets it.
+function channelGate(context) {
+  if (process.platform === 'win32') return withheld({ detail: 'platform-unexamined' });
+  const minimum = CHANNEL_MINIMUM[context.engine];
+  if (supportedVersion(context.engine, context.version, minimum)) return null;
+  const outdated = reason('engine-version-unsupported', { minimum });
+  return [outdated, outdated];
+}
+
+// The first directory that makes a run-folder channel's `folder`, inside a resolved run directory (physicalPath),
+// unsafe to hand an engine that loads what it finds there, or null. Every existing level from the folder up, the
+// folder included, must be a real directory (a link is not one) of this user or root that no one else can write:
+// another user could put a .git or a folder of their own there later. With `git`, no directory from the folder up
+// may hold a .git entry of any kind: Antigravity 1.5.4 loads the agents and hooks of a Git root above an added
+// folder with no trust check. A level that does not exist yet is skipped; a level lstat cannot read cannot be
+// shown safe. Access-control lists are not read.
+function unsafeRunDir(folder, git) {
+  const entry = (file) => {
+    try { return fs.lstatSync(file, { throwIfNoEntry: false }) ?? null; } catch { return false; }
+  };
+  for (let dir = folder; ; dir = path.dirname(dir)) {
+    const stats = entry(dir);
+    if (stats === false || (stats && (!stats.isDirectory() || ![process.getuid(), 0].includes(stats.uid) || stats.mode & 0o022))) return dir;
+    if (git && entry(path.join(dir, '.git')) !== null) return dir;
+    if (dir === path.dirname(dir)) return null;
+  }
+}
+
 function codexRegistrations(config, accountHome) {
   const owned = [], errors = [];
   for (const [key, plugin] of Object.entries(config.plugins || {})) {
@@ -315,11 +563,7 @@ function planActivation(releaseRoot, input, env = process.env) {
   const catalog = skillCatalog(release);
   const instructions = joinText(defaults, catalog);
   const file = (relativePath, utf8) => {
-    let parent = path.resolve(context.runDir);
-    const missing = [];
-    while (!fs.existsSync(parent)) { missing.unshift(path.basename(parent)); parent = path.dirname(parent); }
-    const physical = path.join(fs.realpathSync(parent), ...missing);
-    const relative = path.relative(release.root, physical);
+    const relative = path.relative(release.root, physicalPath(context.runDir));
     if (!relative || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))) {
       fail('invalid-arguments', { argument: 'runDir must be outside the release' }, 2);
     }
@@ -327,11 +571,26 @@ function planActivation(releaseRoot, input, env = process.env) {
     return path.join(context.runDir, relativePath);
   };
   const principles = (mechanism) => { status.principles = channel('configured', mechanism); };
-  const fallback = (reasons = []) => {
-    status.skills = channel('partial', 'absolute-catalog', [...reasons, reason('skills-catalog')]);
+  // The catalog travels in the principles text: without that text only the absolute invocation is left.
+  const fallback = (reasons = [], withCatalog = true) => {
+    status.skills = withCatalog ? channel('partial', 'absolute-catalog', [...reasons, reason('skills-catalog')])
+      : channel('partial', null, reasons);
     status.invocation = { kind: 'read-file', text: `Read ${path.join(release.root, 'config/skills/devlyn-ideate/SKILL.md')}` };
   };
   const native = (mechanism, kind, text) => { status.skills = channel('configured', mechanism); status.invocation = { kind, text }; };
+  // Where no run-folder channel is planned, only a first task carries the principles and the catalog, ahead
+  // of its text; without one nothing reaches the session and each channel gives its reason.
+  const firstTask = ([principlesReason, skillsReason]) => {
+    if (context.initialPrompt) {
+      status.principles = channel('partial', 'initial-task', [reason('principles-task-only')]);
+      plan.prompt = { ...context.initialPrompt, text: joinText(instructions, context.initialPrompt.text) };
+      fallback();
+    } else {
+      status.principles = channel('unavailable', null, [principlesReason]);
+      status.skills = channel('unavailable', null, [skillsReason]);
+    }
+  };
+  // A skill folder that cannot be inspected is also found, so every inspection error comes with a collision.
   const collisions = found.map((entry) => reason('name-collision', { name: entry.name, path: entry.path }));
   switch (context.engine) {
     case 'claude': {
@@ -381,11 +640,39 @@ function planActivation(releaseRoot, input, env = process.env) {
     case 'omp': {
       const skills = { ...config.skills,
         customDirectories: [...new Set([...(config.skills?.customDirectories || []), path.join(release.root, 'config/skills')])] };
-      plan.engineArgs.push('--config', file('devlyn-omp.json', JSON.stringify({ skills }, null, 2) + '\n'),
-        '--append-system-prompt', joinText(config.appendSystemPrompt, instructions));
-      principles('append-system-prompt');
-      if (collisions.length || errors.length || skills.enableSkillCommands === false || skills.ignoredSkills?.length) fallback([...collisions, ...errors]);
-      else native('skills.customDirectories', 'slash', '/skill:devlyn-ideate');
+      // The files in the order `devlyn run` reads them (harness-context.js ompOwnerAppend).
+      const owner = ownerAppend(config, () => ({ files: [path.join(context.cwd, '.omp/APPEND_SYSTEM.md'),
+        path.join(env.HOME || env.USERPROFILE || os.homedir(), '.omp/agent/APPEND_SYSTEM.md')] }));
+      plan.engineArgs.push('--config', file('devlyn-omp.json', JSON.stringify({ skills }, null, 2) + '\n'));
+      // Owner text that cannot be known leaves the flag off, so the engine's own lookup stays intact.
+      if (owner.reason) status.principles = channel('partial', null, [owner.reason]);
+      else {
+        plan.engineArgs.push('--append-system-prompt', joinText(owner.text, instructions));
+        principles('append-system-prompt');
+      }
+      if (collisions.length || errors.length || skills.enableSkillCommands === false || skills.ignoredSkills?.length) {
+        fallback([...collisions, ...errors], !owner.reason);
+      } else native('skills.customDirectories', 'slash', '/skill:devlyn-ideate');
+      break;
+    }
+    case 'pi': {
+      const { agentDir } = piFolders(context.cwd, env);
+      const settings = piSettings(context.cwd, agentDir);
+      const owner = ownerAppend(config, () => piAppendFiles(context.cwd, agentDir, settings.user));
+      if (owner.reason) status.principles = channel('partial', null, [owner.reason]);
+      else {
+        plan.engineArgs.push('--append-system-prompt', file('devlyn-instructions.md', joinText(owner.text, instructions)));
+        principles('append-system-prompt');
+      }
+      // A discovered or settings-named skill wins over a --skill of the same name.
+      const named = piNameCollisions(discoveryRoots(context, env, config), found);
+      const reasons = [...collisions, ...named.collisions, ...errors, ...named.errors, ...settings.errors];
+      if (reasons.length || [settings.user, settings.project].some((scope) => listed(scope, 'skills', 'packages'))) {
+        fallback(reasons, !owner.reason);
+      } else {
+        for (const name of SKILLS) plan.engineArgs.push('--skill', path.join(release.root, 'config/skills', name));
+        native('--skill', 'slash', '/skill:devlyn-ideate');
+      }
       break;
     }
     case 'grok':
@@ -452,14 +739,73 @@ function planActivation(releaseRoot, input, env = process.env) {
         } else fallback([...collisions, ...errors, ...kimi.errors]);
       }
       break;
-    case 'antigravity':
-    case 'cursor':
-      status.principles = channel('partial', context.initialPrompt ? 'initial-task' : null, [reason('principles-task-only')]);
-      if (context.initialPrompt) {
-        plan.prompt = { ...context.initialPrompt, text: joinText(instructions, context.initialPrompt.text) };
-        fallback();
-      } else status.skills = channel('partial', null, [reason('skills-unavailable', { detail: 'no-initial-task' })]);
+    case 'antigravity': {
+      // Antigravity reads AGENTS.md (always on) and .agents/skills in every workspace folder, and a folder given
+      // by --add-dir is one. A conversation keeps its added folders and reads them from disk again on every
+      // launch, so the plan is the same in every launch mode and a caller hands a resumed conversation the same
+      // runDir: with another, both folders apply while the old one exists. A folder removed later only stops
+      // applying. It truncates a rule file over 24,000 bytes.
+      const gate = channelGate(context);
+      if (gate) {
+        firstTask(gate);
+        break;
+      }
+      // The engine is given the resolved folder, the one the checks ran on.
+      const folder = path.join(physicalPath(context.runDir), 'antigravity');
+      const unsafe = unsafeRunDir(folder, true);
+      if (unsafe) {
+        firstTask(withheld({ detail: 'run-dir-unsafe', path: unsafe }));
+        break;
+      }
+      const bytes = Buffer.byteLength(instructions), maximum = 24000;
+      if (bytes > maximum) {
+        status.principles = channel('unavailable', null, [reason('principles-unavailable', { detail: 'too-large', bytes, maximum })]);
+      } else {
+        file('antigravity/AGENTS.md', instructions);
+        principles('add-dir');
+      }
+      if (collisions.length) fallback([...collisions, ...errors], bytes <= maximum);
+      else {
+        for (const name of SKILLS) file(`antigravity/.agents/skills/${name}/SKILL.md`, antigravitySkill(release, name));
+        native('add-dir', 'slash', '/devlyn-ideate');
+      }
+      if (plan.files.length) plan.engineArgs.push('--add-dir', folder);
+      break;
+    }
+    case 'cursor': {
+      const gate = channelGate(context);
+      if (gate) {
+        firstTask(gate);
+        break;
+      }
+      // A --plugin-dir folder's sessionStart command hook runs when a session is created, and Cursor puts the
+      // additional_context it prints before the model as instructions, kept with the conversation (10,200
+      // characters were delivered whole). A resumed chat runs no hook and keeps what its first launch had
+      // (measured); a fork is treated the same way, because what it gets is not established. The hook is a
+      // command Cursor runs, so it is planned only in a safe run directory, by its resolved absolute path, quoted
+      // for the shell: no lookup through PATH or the working folder. The skills come from the release, whatever
+      // the run directory.
+      const hook = path.join(physicalPath(context.runDir), 'cursor');
+      const unsafe = unsafeRunDir(hook);
+      if (unsafe || !isFile('/bin/cat')) {
+        firstTask(withheld(unsafe ? { detail: 'run-dir-unsafe', path: unsafe } : { detail: 'platform-unexamined' }));
+      } else {
+        const command = `/bin/cat '${path.join(hook, 'context.json').replace(/'/g, "'\\''")}'`;
+        file('cursor/hooks/hooks.json', JSON.stringify({ version: 1, hooks: { sessionStart: [{ command }] } }) + '\n');
+        // Every non-ASCII character escaped, so no shell or code page can change the text.
+        file('cursor/context.json', JSON.stringify({ additional_context: instructions })
+          .replace(/[\u0080-\uffff]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`) + '\n');
+        plan.engineArgs.push('--plugin-dir', hook);
+        status.principles = continuation ? channel('partial', 'session-start-hook', [reason('principles-session-start-only')])
+          : channel('configured', 'session-start-hook');
+      }
+      if (collisions.length) fallback([...collisions, ...errors], plan.files.length > 0 || plan.prompt !== null);
+      else {
+        plan.engineArgs.push('--plugin-dir', path.join(release.root, 'config'));
+        native('plugin-dir', 'slash', '/devlyn-ideate');
+      }
       break;
+    }
   }
   if (plan.engineArgs.length || Object.keys(plan.envPatch).length || plan.prompt) plan.envPatch.DEVLYN_HARNESS_ROOT = release.root;
   return finish(plan);
@@ -473,4 +819,4 @@ function activationCommand(args) {
   return planActivation(opts['release-root'], readContext(opts['context-file']));
 }
 
-module.exports = { planActivation, activationCommand, readContext, toml, skillCatalog };
+module.exports = { planActivation, activationCommand, readContext, toml, skillCatalog, piFolders };

package/bin/harness-context.js

@@ -8,7 +8,7 @@ const path = require('path');
 const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
-const { verifyRelease, materializeRelease, fail } = require('./release');
+const { physicalRoot, materializeRelease, fail } = require('./release');
 
 const ENGINES = Object.freeze(['claude', 'codex', 'omp']);
 const READ_MS = 6000;
@@ -209,13 +209,13 @@ function appState(home, common) {
   return { defaultRelease: state.defaultRelease || null, choice };
 }
 
-// A release chosen by a record must verify as recorded; it never yields to another release.
+// A release chosen by a record must be the one recorded; its own planner verifies its files.
 function recorded(root, version, digest, source) {
-  let release;
-  try { release = verifyRelease(root).release; }
-  catch (error) { fail('release-unavailable', { source, version, detail: error.reason?.code || error.message }, 3); }
-  if (release.version !== version || release.digest !== digest) fail('release-version-conflict', { source, version }, 3);
-  return { release, source };
+  let manifest;
+  try { root = physicalRoot(root); manifest = JSON.parse(fs.readFileSync(path.join(root, 'release.json'), 'utf8')); }
+  catch (error) { fail('release-unavailable', { source, version, detail: error.reason?.code || error.code || 'unreadable' }, 3); }
+  if (manifest?.version !== version || manifest?.digest?.value !== digest) fail('release-version-conflict', { source, version }, 3);
+  return { release: { package: 'devlyn-cli', version, digest, root }, source };
 }
 
 // The release a terminal launch plans with: an unfinished queue's bound release in this repository,

package/bin/instruction-templates.json

@@ -494,6 +494,7 @@
       "cc8bf51efb9ef8e5fa4134743f2d25434f4fd51595128edcfd2331dbf29d7dd5",
       "ccacf091bab4102d7156631c6227120a661bb4ec0df514e14a59db44b7bd5dfd",
       "ce1b0d9d0621fd057e684dc18b43156d30f589c72ed20189ea1232ea4f7ce6c6",
+      "ce8c1ea5c851fed75b898759fcf8359bd95ec04b30e547ed06bdf4101a2dddd8",
       "cebacda3b11db7aa161d96b12edd6f3f790ee2850404cd42ecdf2912ed53de08",
       "cefad7acb7dcd92777f888081aa6585b1418aa581366736fd44db68b1bd66dd0",
       "cf43eb0460beebdfe1efbfb1a35a39e5fe450137252ea2c83e51d978faa1f17e",
@@ -1024,6 +1025,7 @@
       "ce351bfa301b000f0786cac24959108a3db6cdf1cad3733cb07b394c62d35227",
       "ce3cceeb74119953afde95da84dbe1bd6e3da3dbde5f85dd123a0fe8afec5d36",
       "ce4b307083addc337a833547cb6998cb34a38d82e572587e9a57dc2cf46d275a",
+      "ce8c1ea5c851fed75b898759fcf8359bd95ec04b30e547ed06bdf4101a2dddd8",
       "ce9c73a3305e4ec9cd559cec6fdd10b8f4a9f3124b42ea4598340dc16a575505",
       "ceddbf09792093c7417e72c7e2cf08e4780e9798dcd107292cdd095b023c2a8c",
       "cf04e7c73e16d8e0e561e89d4a6519a1c47b9ffa08f88d1e5bda75ad2983f4df",

package/bin/skill-history.json

@@ -4,6 +4,7 @@
     "_shared": [
       "015eea12cc07cfb9eb318c30855f6deacb5bf43bd508a511dffd2e48c9d82964",
       "0544f4e90951233c6cbe99755fb5c95728d7429b8b4ce5dd6e2829dd0816524c",
+      "0575d3635d8ec6f72120309a93af17e1801c636d3cf2b426d2feec064230c500",
       "05935881380d65ba34a964592e4587534fcea034b43b13673eff4108ed9389fd",
       "06ab3a4b9e1c97d9b3dcd238148d775f1165f3fc08898af2f3b76149162b78d3",
       "082124278a538e4ea8b6622d767f996e3d818ec85d6e0d8ddddafe9bb03118b2",
@@ -17,6 +18,7 @@
       "135f09d5382b4d375204bba3ff6fb3f6fdc34a1ec89fe88542da02d12dda0f0d",
       "1504c7a41e5f4a3206288d05e66fb48847222864f7825f05633883e2c562ec77",
       "161cb4f1b27a9f81ae1e96af6ff596399c8936578a11d601108a89cbdeea241d",
+      "16811f6cf716d3931562be0da4dae13b6aa5a9a126029a8ccddb7c797d0cb652",
       "196afa14871099a9afc4e484b00e8d8ccd928dba79db95a6a8776f58c8e78c39",
       "1c1e5e44ff704b1b8791fabcad79a4158d8cd2f024569c1685ec3b185a98fbcc",
       "20ac702b463f3eaa07fd6686d5209aed7993773504e35896fc732f7e653ec6cd",
@@ -72,6 +74,7 @@
       "59f0ecc2c1fd9620e4cac06be370e0bf9965a35c20616047445dbc42da6a1677",
       "5b8541a98c06de50443c2c3905c1b92ba143a972dfe618c4b296b799e0e1673c",
       "5be2e643f96b6ce503ae8d631c67729f0c24b6c5d2b431c087161b520ccbe417",
+      "5d3d614f8a75ae7cf1b5e29036e963ce76cf817fe9bd86457a4f8ff026b0036f",
       "60cdd1a8b220e629bcba3a24652323d16e3e6a15ba5b07c69ef2785a9c2eca70",
       "61ec4c0435a2f0b307df8e88d81d9862c3abc1bf758648f2c18039581596659b",
       "628a40e873d156e9179fd5a6bb3da9f910b6dde0886055804a506cdf8a631aaa",
@@ -121,6 +124,7 @@
       "97e7ad89c74c609b15dfbf6f9f7ac61df8b50e97e4bc318f72922e058ecffba4",
       "9815b6e6963e068872a6dbeae24068143bf92042bb035f67bafd1a224d65bcb0",
       "998343c148618b937556b58b83749c05d5aa3283280d751c118da6a542fb87f2",
+      "9ca5956a73070555a93f19ecb1f92a8f57cec6fd1170a2809eeacc49cc0841be",
       "9dd3ec225818efe0ad3726192db94ff129154e995617a9d3c150fc58ad0f9f2c",
       "9e4d06fd466fa896040109bac0018fcfb2f1604d55abb4180ff1f1a0b665bbc8",
       "9f14ca629e41730b1a9fb5d0ad1a39cff558fe34758d6ceccbb9de498f9f384e",
@@ -175,6 +179,7 @@
       "e0a305cf3bf47c8bc357195d4d50b0f6177069e870c33040c258c93edae68646",
       "e115205a744fef918a59d1b3a601df09a8b6df1d3e60613b9e8b87240929f8d8",
       "e19204055bb16fff4263f95fac092ee8f971ee9055b7a969497e5714782a454c",
+      "e2a8157e0467cbe0c7cff583e34629bbd69c906830a1530a0e69a4cf4c448f2e",
       "e41013abf5e17445ef83a86974ac1de77beaa61e484e1916577ecc64bb34c220",
       "e725ec4eca42f737ee4bdaceb10c11db289414a1d4bb8be8fe103f89c89f07d5",
       "e812d02ebdbdb8d82eb85842d676e21bedddb0d00154eed99b9d29b43cb8fc02",
@@ -193,6 +198,7 @@
       "f9617e1034543f31ae2a3820301fbac6e4674e5d6fbc0d4b76751fe87b8e013e",
       "fd68c7a74272929a14e685e447a51058ffcdd4c1d6bef83cbba18045c07aee55",
       "fdb608b34a8600b4ce209d7f645ec5ad4475948be6ad95c941cc7ef02b5959df",
+      "fe357defe8ac6efd6bbd15b3bf35f79d79761c0f56d507488d9428536d4fb5f7",
       "fe386122e502410394ab60643e79aa736ddb5030257c863f4a198e23b56b4cef",
       "feaa255b2b6a7b0dc79877c4eb620c0f3cac88b50d2d1407a0a8a02ebc08ed49"
     ],
@@ -321,6 +327,7 @@
       "89f0efaa2efdfddc887b494138247980d97856f6cabe6a8dcc585b3a28e5fa88",
       "9bc8113592de34a7d559d8a5db6253e472357e947010ea2304701f1f7de3643d",
       "ee723ff072721cae3f5e130d72515d44414337cffadb9615902b0d578912bda2",
+      "fc2710a0ed3eb0aeb7d095378bcbd1c77a5c46d0973bda7a49f6ec0a173adb2c",
       "fed622aa1bcf9a3b437d42c39f6b35403c8cde657be0685b93bbe864e82ca8c4"
     ],
     "devlyn-evaluate": [
@@ -348,6 +355,7 @@
       "15f3eca3fad92b199814a00d42e4005a2838a40d800b9f755f7165d31773e7c9",
       "19207315f23c9a12bf2ced0e4e79bb7dfdc7cc5d0c9dd94095d9c6dfe1e8fea8",
       "1d8c3bd31c8b755acd0c3c9f416acb5024dfa99fbf5e2c14d8d6df00a24fe9b4",
+      "2e5b05df1af5891761a6460328d3a1b95aa6ead1b373b5147de6388f7cb98df2",
       "300d1af60cc53285935dc4b5b370e157707218d844a4303b96d7826eef36ed43",
       "302b1a6c109087dce02ed6af184d6aeeca6cecfd40ebe638beecf8bdf21cf59c",
       "338a2b5ddde0f09444040c45922716663b1df76ec1a6c97ebdeb770b9e3ede49",
@@ -364,6 +372,7 @@
       "6374290c74a8c17979e8c128905e106d38bd810c0451f0e9240c30e0f7ecabb0",
       "65770e3f20c3a3afd2822e9acdcfc80b827f84a7737010b79332da70d431b05d",
       "65c781764633b912e5947362eba0837c8027461a904975401d79ad4fe8714084",
+      "65ec310be43384375852e31ba3458313b01052668543849186a70715bfa81dcc",
       "694c8920e50d92cba46dbb27eb44dd88035a89ed625d3cbf9f2bce9366d44c96",
       "6b3143bcfe9c60a76f142d533177d85d36f856a163a226351317ed688738c05a",
       "6b403afbf5a117cc08603d3648b9dded4f9ac4ca02fc1d8e1f0035615148bb5c",
@@ -390,6 +399,7 @@
       "c8e375aab574148542f392b093cbbf3f2e8dc623826b45e35df0a1a2c3862226",
       "ce282a55328c2d071cacc377670fbebea4da4b9a7fee81b25293fb26763f17c9",
       "cf61a917a804503ef1e26fbb1cf498181e843a0758ec001f84edb7bcac837448",
+      "d622e92c7bf32d315a5aabe2554efbc9f62790ace19a088ead9a7cef195fc715",
       "d6433bf0f96dd9dd485c3623885255738654674b3e23cfcc1a2cfd24f3cda96e",
       "db8d921aabf0d04811b55465a3757c62c4b39631aebaf6eecc994ca241cfbe56",
       "e25da746dc37b2e82c658a28d9481fd69741151045683eee2119582ddaf731cd",
@@ -812,7 +822,9 @@
     "4.3.26",
     "4.3.27",
     "4.3.28",
+    "4.3.29",
     "4.3.3",
+    "4.3.30",
     "4.3.4",
     "4.3.5",
     "4.3.6",

package/config/skills/_shared/engine-doctor.sh

@@ -29,7 +29,7 @@ check_binary() {
 
 check_adapter() {
   # $1 = target name
-  if [ -f "$ADAPTERS_DIR/$1.md" ]; then printf 'yes'; else printf 'no'; fi
+  if [ -f "$ADAPTERS_DIR/$1.adapter.md" ]; then printf 'yes'; else printf 'no'; fi
 }
 
 check_executor() {
@@ -47,7 +47,7 @@ for i in "${!TARGETS[@]}"; do
   kind="${KINDS[$i]}"
   binary="$(check_binary "${BINARIES[$i]}")"
   adapter="$(check_adapter "$target")"
-  executor="$(check_executor "$ADAPTERS_DIR/$target.md")"
+  executor="$(check_executor "$ADAPTERS_DIR/$target.adapter.md")"
 
   note='-'
   case "$kind" in