devlyn-cli 4.3.28 → 4.3.29

package/bin/harness-activation.js

@@ -11,6 +11,7 @@ const SKILLS = ['devlyn-ideate', 'devlyn-engines'];
 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 +91,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,8 +122,20 @@ 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;
@@ -135,10 +149,11 @@ 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) && (engine !== 'copilot' || copilotDefaultHome)) add(engine === 'pi' ? pi.agentsHome : home, '.agents/skills');
   if (['omp', 'opencode', 'grok'].includes(engine)) add(home, '.claude/skills');
   if (engine === 'omp') {
     add(home, '.codex/skills'); add(home, '.agent/skills');
@@ -150,6 +165,7 @@ 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');
   for (let dir = path.resolve(context.cwd); ; dir = path.dirname(dir)) {
     if (native[1]) add(dir, native[1], 'skills');
     if (!['claude', 'cursor'].includes(engine)) add(dir, '.agents/skills');
@@ -187,6 +203,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)) {
@@ -327,8 +490,10 @@ 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 }; };
@@ -381,11 +546,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':
@@ -454,11 +647,15 @@ function planActivation(releaseRoot, input, env = process.env) {
       break;
     case 'antigravity':
     case 'cursor':
-      status.principles = channel('partial', context.initialPrompt ? 'initial-task' : null, [reason('principles-task-only')]);
+      // Only a first task carries the principles and the catalog: without one nothing reaches the session.
       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.skills = channel('partial', null, [reason('skills-unavailable', { detail: 'no-initial-task' })]);
+      } else {
+        status.principles = channel('unavailable', null, [reason('principles-unavailable', { detail: 'no-initial-task' })]);
+        status.skills = channel('unavailable', null, [reason('skills-unavailable', { detail: 'no-initial-task' })]);
+      }
       break;
   }
   if (plan.engineArgs.length || Object.keys(plan.envPatch).length || plan.prompt) plan.envPatch.DEVLYN_HARNESS_ROOT = release.root;
@@ -473,4 +670,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/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",
@@ -175,6 +178,7 @@
       "e0a305cf3bf47c8bc357195d4d50b0f6177069e870c33040c258c93edae68646",
       "e115205a744fef918a59d1b3a601df09a8b6df1d3e60613b9e8b87240929f8d8",
       "e19204055bb16fff4263f95fac092ee8f971ee9055b7a969497e5714782a454c",
+      "e2a8157e0467cbe0c7cff583e34629bbd69c906830a1530a0e69a4cf4c448f2e",
       "e41013abf5e17445ef83a86974ac1de77beaa61e484e1916577ecc64bb34c220",
       "e725ec4eca42f737ee4bdaceb10c11db289414a1d4bb8be8fe103f89c89f07d5",
       "e812d02ebdbdb8d82eb85842d676e21bedddb0d00154eed99b9d29b43cb8fc02",
@@ -193,6 +197,7 @@
       "f9617e1034543f31ae2a3820301fbac6e4674e5d6fbc0d4b76751fe87b8e013e",
       "fd68c7a74272929a14e685e447a51058ffcdd4c1d6bef83cbba18045c07aee55",
       "fdb608b34a8600b4ce209d7f645ec5ad4475948be6ad95c941cc7ef02b5959df",
+      "fe357defe8ac6efd6bbd15b3bf35f79d79761c0f56d507488d9428536d4fb5f7",
       "fe386122e502410394ab60643e79aa736ddb5030257c863f4a198e23b56b4cef",
       "feaa255b2b6a7b0dc79877c4eb620c0f3cac88b50d2d1407a0a8a02ebc08ed49"
     ],
@@ -321,6 +326,7 @@
       "89f0efaa2efdfddc887b494138247980d97856f6cabe6a8dcc585b3a28e5fa88",
       "9bc8113592de34a7d559d8a5db6253e472357e947010ea2304701f1f7de3643d",
       "ee723ff072721cae3f5e130d72515d44414337cffadb9615902b0d578912bda2",
+      "fc2710a0ed3eb0aeb7d095378bcbd1c77a5c46d0973bda7a49f6ec0a173adb2c",
       "fed622aa1bcf9a3b437d42c39f6b35403c8cde657be0685b93bbe864e82ca8c4"
     ],
     "devlyn-evaluate": [
@@ -348,6 +354,7 @@
       "15f3eca3fad92b199814a00d42e4005a2838a40d800b9f755f7165d31773e7c9",
       "19207315f23c9a12bf2ced0e4e79bb7dfdc7cc5d0c9dd94095d9c6dfe1e8fea8",
       "1d8c3bd31c8b755acd0c3c9f416acb5024dfa99fbf5e2c14d8d6df00a24fe9b4",
+      "2e5b05df1af5891761a6460328d3a1b95aa6ead1b373b5147de6388f7cb98df2",
       "300d1af60cc53285935dc4b5b370e157707218d844a4303b96d7826eef36ed43",
       "302b1a6c109087dce02ed6af184d6aeeca6cecfd40ebe638beecf8bdf21cf59c",
       "338a2b5ddde0f09444040c45922716663b1df76ec1a6c97ebdeb770b9e3ede49",
@@ -364,6 +371,7 @@
       "6374290c74a8c17979e8c128905e106d38bd810c0451f0e9240c30e0f7ecabb0",
       "65770e3f20c3a3afd2822e9acdcfc80b827f84a7737010b79332da70d431b05d",
       "65c781764633b912e5947362eba0837c8027461a904975401d79ad4fe8714084",
+      "65ec310be43384375852e31ba3458313b01052668543849186a70715bfa81dcc",
       "694c8920e50d92cba46dbb27eb44dd88035a89ed625d3cbf9f2bce9366d44c96",
       "6b3143bcfe9c60a76f142d533177d85d36f856a163a226351317ed688738c05a",
       "6b403afbf5a117cc08603d3648b9dded4f9ac4ca02fc1d8e1f0035615148bb5c",
@@ -812,6 +820,7 @@
     "4.3.26",
     "4.3.27",
     "4.3.28",
+    "4.3.29",
     "4.3.3",
     "4.3.4",
     "4.3.5",

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

package/config/skills/_shared/engine-preflight.md

@@ -4,7 +4,7 @@ Used by `/devlyn-ideate` and `/devlyn-engines`: one rule for which engine execut
 
 ## Selection
 
-The executor is the `executor` pin in `.devlyn/engines.json` at the checkout root (set with `/devlyn-engines executor <name>`), else the CLI the user opened. A linked worktree or subdirectory has no pin unless one is set there. Pi and Grok have no executor adapter, so a drain from them needs a claude, codex or omp pin. Keys earlier releases wrote for retired pipeline roles (`pair_judge_priority`, `roles`) stay as written and select nothing: a worker profile never becomes the executor.
+The executor is the `executor` pin in `.devlyn/engines.json` at the checkout root (set with `/devlyn-engines executor <name>`), else the CLI the user opened. A linked worktree or subdirectory has no pin unless one is set there. Only Claude and Codex can execute, so a drain from any other CLI needs a claude or codex pin. Keys earlier releases wrote for retired pipeline roles (`pair_judge_priority`, `roles`) stay as written and select nothing: a worker profile never becomes the executor.
 
 Before dispatching to the executor, run:
 
@@ -16,7 +16,7 @@ A pin is a promise. When the pinned engine's CLI is unavailable, the command exi
 
 ## Engines
 
-An engine is pinnable when `_shared/adapters/<name>.md` exists and does not declare `executor: no` under `## Role eligibility`. Adapters ship with devlyn-cli releases, and a reinstall replaces `_shared`. An adapter's `## Invocation` says how to start it. On native Windows, use native Node/npm and Python (`python3` on PATH), with Git for Windows Bash for the shipped shell wrapper.
+An engine is pinnable when `_shared/adapters/<name>.adapter.md` exists and does not declare `executor: no`. Adapters ship with devlyn-cli releases, and a reinstall replaces `_shared`. An adapter's `## Invocation` says how to start it. On native Windows, use native Node/npm and Python (`python3` on PATH), with Git for Windows Bash for the shipped shell wrapper.
 
 ## Reporting a blocked engine
 

package/config/skills/_shared/managed-storage.md

@@ -0,0 +1,80 @@
+# Managed storage
+
+New allocation and warming modes come from enrollment state alone:
+
+| `~/.devlyn/storage-client.json` | recovery marker | unenroll journal | Mode |
+|---|---|---|---|
+| absent | absent | not read | standalone (never enrolled) |
+| valid | any | not read | managed; a fenced authority refuses |
+| invalid or unreadable | any | not read | refuse; repair registration |
+| absent | present | verified `retired: true` | standalone (unenrollment complete) |
+| absent | present | absent, unreadable or incomplete | refuse; Open Devlyn to repair its storage registration |
+
+An unfinished retirement takes precedence over enrollment; follow its
+operation-specific retained-helper resume to reconcile or cancel as named.
+The journal `storage-client-unenroll.json` is read no-follow for retirement
+recovery and the last two rows. Schema 1, canonical UUIDv7 operation, permanent `storage-client-fence.json`,
+matching operation/root/lock identities and Rust's archive ordering/path
+validation are required. If native root/lock identities or the home path changed,
+completed retirement permits standalone only when `storage`, `control`,
+`harness/state.json` and `storage-client.json` are all absent under the current
+lifecycle root (checked without following links). Live inventory requires repair.
+No repository-wide receipt scan selects mode. Other keys can allocate after
+completed unenrollment; a leftover managed key retains its own recovery command.
+
+Existing operations keep their managed identity. Receipts pin the control
+identity; current enrollment verifies the helper before allocation. Recovery uses
+the current verified `storage-client-recovery/pins.json`, including after uninstall
+or unenrollment, and requires its authority binding to match the receipt, except
+for a proven moved task: use its unflagged, operation-specific `recover-storage`
+resume to release it, retain its files, and archive its receipt under `moved/`. Missing
+or invalid pins retain resources and require repair; saved artifacts are never a
+fallback. Enrolled checkout preserves
+`managed_pending`/`managed_owned` and Rust's `storage-allocation.json` subreceipt.
+After an interrupted reply, use the returned `recover-storage` resume. Never
+delete managed receipts or replace an unfinished operation ID.
+
+Owner `recover-storage --receipt <receipt.json> --operation-id <saved ID>
+--for-removal` fences allocation and reconciles closure and the exact cache set.
+Never-published allocations are abandoned. Accepted LOCAL_ONLY, FAILED, and PRs
+observed CLOSED without merge share custody/recovery-ref verification and fenced
+removal, retaining task branches and a durable terminal delivery. Release writers
+with `complete --writers-stopped` first. A queue-produced FAILED checkout is
+advanced by `read-tree -m -u <source_sha> <publish_sha>` only when HEAD is at the
+attached publish commit and the index and worktree are exactly at source; other
+differences refuse as dirty.
+
+Removal-finished receipts with final COMPLETE, LOCAL_ONLY, FAILED or CLOSED
+delivery move under `devlyn-completion/retired/`, regardless of scratch status.
+Retirement moves scratch and its saved cleanup record with the audit and deletes
+nothing. `complete --writers-stopped` saves the writer release there and retries
+pending scratch, including an interrupted cleanup with no saved result; the next
+allocation retries completed deliveries with released writers. `clean-scratch`
+remains available there and never downgrades CLEAN.
+Saved managed `complete`, `recover-storage` and `clean-scratch` resumes carry an
+operation ID validated under the receipt lock. Without an ID, a locator selects
+its active receipt. An ID selects only that operation, including its verified
+retired receipt; a mismatched ID refuses. Retired paths also remain usable.
+A new allocation may reuse a retired key without disturbing its audit.
+
+Retained submodule repositories in the admin directory block removal even when
+the checkout is absent; preserve/publish their source and explicitly resolve
+them. Manual checkout removal is advised only after portable source checks and
+record preservation succeed; changed or new source requires retention. If native
+Windows or unobservable writers then require retention, stop all
+writers, remove the task checkout by hand, keep its branch and receipt, then run
+the returned owner-removal resume. The absent-tree path completes the fenced
+registration removal. Scratch cleanup requires positive allocation closure,
+without a cache-removal fence; actual checkout removal owns that fence, including
+empty cache sets. Missing helpers or uncertain closure retain resources with a
+repair/resume action. Compatible recovery artifacts and Rust's LaunchGate remain
+required while managed obligations exist.
+
+Managed allocations currently start cold; `build_dirs` retains each returned cache
+and publication lease ID. Managed warming is deferred. Standalone allocations keep
+the warming behavior in [task-completion.md](task-completion.md).
+
+For managed receipts, use the saved `clean-scratch` resume with `--operation-id <saved ID>`.
+
+New managed allocations use the recovery ref `refs/devlyn/completed/<id>.<operation>` so branch reuse
+preserves earlier recovery refs.

package/config/skills/_shared/platform-support.py

@@ -327,7 +327,9 @@ if os.name == "nt":
             self.creating = False
             self.interrupted_signal = None
 
-        def start(self, argv, stdin):
+        def start(self, argv, stdin, **popen):
+            """Launch argv, a list or a command line passed verbatim, inside this job; `popen` passes cwd, env and
+            streams to the enclosed bootstrap, whose target inherits them."""
             self.handle = _kernel.CreateJobObjectW(None, None)
             limits = _ExtendedLimits()
             limits.BasicLimitInformation.LimitFlags = 0x2000  # KILL_ON_JOB_CLOSE; no breakaway.
@@ -346,13 +348,15 @@ if os.name == "nt":
                     os.set_handle_inheritable(handle, True)
                 startup = subprocess.STARTUPINFO()
                 startup.lpAttributeList = {"handle_list": inherited}
+                # A list travels element by element, a command line verbatim as one element; a mode word tells which.
                 command = [sys.executable, "-I", "-S", str(Path(__file__).resolve()), "--job-bootstrap",
-                           str(inherited[0]), str(inherited[2]), str(inherited[1]), *argv]
+                           str(inherited[0]), str(inherited[2]), str(inherited[1]),
+                           *(("line", argv) if isinstance(argv, str) else ("argv", *argv))]
                 # Retain the Popen object even if __init__ raises after native creation.
                 self.child = subprocess.Popen.__new__(subprocess.Popen)
                 self.creating = True
                 try:
-                    self.child.__init__(command, stdin=stdin, startupinfo=startup, close_fds=True)
+                    self.child.__init__(command, stdin=stdin, startupinfo=startup, close_fds=True, **popen)
                 finally:
                     self.creating = False
                 if self.interrupted_signal is not None:
@@ -424,6 +428,11 @@ if os.name == "nt":
 
     def _job_bootstrap(argv):
         job, allow, ready = map(int, argv[:3])
+        mode, command = argv[3], argv[4:]
+        if mode == "line":
+            command, = command
+        elif mode != "argv":
+            raise ValueError(f"unknown job target mode {mode!r}")
         with contextlib.ExitStack() as handles:
             allow_fd = msvcrt.open_osfhandle(allow, os.O_RDONLY | os.O_BINARY)
             handles.callback(os.close, allow_fd)
@@ -436,50 +445,77 @@ if os.name == "nt":
             os.write(ready_fd, b"R")
             if _read_control(allow_fd, 1) != b"G":
                 raise OSError("Windows job launch was not authorized")
-            with subprocess.Popen(argv[3:], stdin=sys.stdin.buffer, close_fds=True) as target:
+            with subprocess.Popen(command, stdin=sys.stdin.buffer, close_fds=True) as target:
                 os.write(ready_fd, target.pid.to_bytes(4, "little"))
                 return target.wait()
 
 
+def _signal_group(child, sig):
+    """Send `sig` to the child's process group; False once it has no member this process may signal. An exited leader
+    is reaped first: until then it still counts as a member."""
+    child.poll()
+    try:
+        os.killpg(child.pid, sig)
+    except ProcessLookupError:
+        return False
+    except PermissionError:  # EPERM: no member this process may signal; with the leader alive the run cannot be ended.
+        if child.poll() is None:
+            raise
+        return False
+    return True
+
+
 def terminate_tree(child, job=None):
     if job is not None:
         job.terminate()
         return
-    try:
-        os.killpg(child.pid, signal.SIGTERM)
-    except ProcessLookupError:
-        child.wait()
-        return
-    # Reap the leader and retain the grace period for its surviving descendants.
-    deadline = time.monotonic() + 5
-    try:
-        child.wait(timeout=5)
-    except subprocess.TimeoutExpired:
-        pass  # The leader also needs the final group KILL below.
-    time.sleep(max(0, deadline - time.monotonic()))
-    try:
-        os.killpg(child.pid, signal.SIGKILL)
-    except ProcessLookupError:
-        pass  # Every member already exited during the grace period.
-    child.wait()
+    # SIGTERM and up to 5 s for the group to leave, then SIGKILL and about 1 s more; what still answers then is dead but
+    # unreaped or may not be signalled, which cannot be told apart. A member this process cannot signal, or one that left
+    # the session, is not owned; acceptance.py's evidence is safe from it because no check process holds an evidence file.
+    for sig, seconds in ((signal.SIGTERM, 5), (signal.SIGKILL, 1)):
+        deadline = time.monotonic() + seconds
+        alive = _signal_group(child, sig)
+        while alive and time.monotonic() < deadline:
+            time.sleep(0.01)
+            alive = _signal_group(child, 0)
+        if not alive:
+            return
 
 
-def run_process(argv, stdin, seconds, *, heartbeat=0):
+def run_process(argv, stdin, seconds, *, heartbeat=0, on_timeout=124, **popen):
+    """Run argv as an owned tree (its own POSIX session or Windows job), ended whole however the run ends; `popen`
+    passes cwd, env and streams. Returns the exit status, or `on_timeout` once `seconds` pass. On Windows argv may be a
+    command line passed verbatim."""
     child = None
     job = _WindowsJob() if os.name == "nt" else None
     previous = {}
+    received = []  # Every handled signal; the first ends the run with 128 + it once the tree has ended.
+    deferring = False  # While set, a signal only waits: a POSIX child's creation and the teardown are not interrupted.
 
     def interrupted(signum, _frame):
+        received.append(signum)
         # CPython stores the native handle only after CreateProcess's finally block.
         if job is not None and job.creating:
             job.interrupted_signal = signum
-            return
-        raise SystemExit(128 + signum)
+        elif not deferring:
+            raise SystemExit(128 + signum)
 
     try:
-        for sig in (signal.SIGTERM, signal.SIGINT):
-            previous[sig] = signal.signal(sig, interrupted)
-        child = job.start(argv, stdin) if job is not None else subprocess.Popen(argv, stdin=stdin, start_new_session=True)
+        handled = [signal.SIGTERM, signal.SIGINT]
+        if os.name != "nt" and signal.getsignal(signal.SIGHUP) is not signal.SIG_IGN:
+            # A closed terminal hangs up the runner, not the child's own session; an inherited ignore (nohup) stays.
+            handled.append(signal.SIGHUP)
+        for sig in handled:
+            previous[sig] = signal.getsignal(sig)  # Saved first: a signal right after installation finds it to restore.
+            signal.signal(sig, interrupted)
+        if job is not None:
+            child = job.start(argv, stdin, **popen)
+        else:
+            deferring = True  # Raised inside Popen, a signal would leave the new session unowned.
+            child = subprocess.Popen(argv, stdin=stdin, start_new_session=True, **popen)
+            deferring = False
+            if received:
+                raise SystemExit(128 + received[0])
         started = time.monotonic()
         next_heartbeat = started + heartbeat
         if heartbeat:
@@ -492,17 +528,20 @@ def run_process(argv, stdin, seconds, *, heartbeat=0):
                 if seconds and now - started >= seconds:
                     if heartbeat:
                         print(f"[codex-monitored] timeout: elapsed={int(now-started)}s limit={seconds}s", file=sys.stderr, flush=True)
-                    return 124
+                    return on_timeout
                 if heartbeat and now >= next_heartbeat:
                     print(f"[codex-monitored] heartbeat: elapsed={int(now-started)}s", file=sys.stderr, flush=True)
                     next_heartbeat = now + heartbeat
     finally:
+        deferring = True  # Teardown runs to its end.
         try:
             if job is not None or child is not None:
                 terminate_tree(child, job)
         finally:
             for sig, handler in previous.items():
                 signal.signal(sig, handler)
+            if received:  # Whenever it came and whatever teardown raised, a signal ends the run.
+                raise SystemExit(128 + received[0])
 
 
 if __name__ == "__main__" and os.name == "nt":