devlyn-cli 4.2.25 → 4.3.0

package/bin/instructions.js

@@ -13,12 +13,21 @@ const digest = (text) => crypto.createHash('sha256').update(text).digest('hex');
 
 class InstructionError extends Error {}
 
-function managedBlock(template, eol) {
-  const body = 'Project-specific instructions outside this managed block take precedence over these defaults.\n\n'
+function managedBody(template) {
+  return 'Project-specific instructions outside this managed block take precedence over these defaults.\n\n'
     + normalize(template).replace(/\n?$/, '\n');
+}
+
+function managedBlock(template, eol = '\n') {
+  const body = managedBody(template);
   return `${BEGIN} sha256=${digest(body)} -->\n${body}${END}\n`.replace(/\n/g, eol);
 }
 
+function sessionDefaults(template) {
+  return 'The following Devlyn instructions are defaults for this session. Applicable explicit user instructions and native owner/project instructions take precedence over these defaults. This delegation applies only to the Devlyn defaults below; it does not change other engine instructions or permissions.\n\n'
+    + normalize(template);
+}
+
 function matchedEnd(text, start, template) {
   let end = start;
   for (let n = 0; n < template.length && end < text.length; n++, end++) {
@@ -335,4 +344,5 @@ function updateInstructions(name, initial = '', withBlock = true, write = true,
   return true;
 }
 
-module.exports = { updateInstructions, InstructionError, instructionParagraphs, holdsDevlynDefaults, importsAgentsMd };
+module.exports = { updateInstructions, InstructionError, instructionParagraphs, holdsDevlynDefaults, importsAgentsMd,
+  managedBody, managedBlock, sessionDefaults };

package/bin/release.js

@@ -0,0 +1,381 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+const { parseArgs } = require('util');
+const { managedBody, managedBlock, sessionDefaults } = require('./instructions');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const CORE = ['devlyn-ideate', 'devlyn-engines', '_shared'];
+const DEFAULTS = 'config/skills/_shared/runtime-principles.md';
+const SHA256 = /^[a-f0-9]{64}$/;
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+
+class HarnessError extends Error {
+  constructor(code, params = {}, exitCode = 1) {
+    super(`${code}: ${JSON.stringify(params)}`);
+    this.reason = { code, params };
+    this.exitCode = exitCode;
+  }
+}
+function fail(code, params, exitCode) { throw new HarnessError(code, params, exitCode); }
+const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+function manifestDigest(manifest) {
+  const { digest, ...body } = manifest;
+  return sha256(canonical(body));
+}
+const jsonBytes = (value) => Buffer.from(JSON.stringify(value, null, 2) + '\n');
+
+// POSIX manifest names must also be unambiguous on Windows and macOS volumes.
+function validatePath(name) {
+  if (typeof name !== 'string' || !name || /[\\\x00-\x1f\x7f:<>"|?*]/.test(name)
+      || path.posix.isAbsolute(name) || path.win32.isAbsolute(name)
+      || name.split('/').some((part) => !part || part === '.' || part === '..' || /[. ]$/.test(part)
+        || /^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(part))) {
+    fail('release-unsafe-path', { path: String(name) });
+  }
+}
+function validatePaths(names) {
+  const seen = new Map();
+  const files = new Set();
+  for (const name of names) {
+    validatePath(name);
+    if (files.has(name)) fail('release-duplicate-path', { path: name });
+    files.add(name);
+    const parts = name.split('/');
+    for (let i = 1; i <= parts.length; i++) {
+      const prefix = parts.slice(0, i).join('/');
+      const folded = prefix.normalize('NFC').toUpperCase().toLowerCase().toUpperCase();
+      if (seen.has(folded) && seen.get(folded) !== prefix) fail('release-case-collision', { path: name });
+      seen.set(folded, prefix);
+    }
+  }
+  for (const name of names) {
+    const parts = name.split('/');
+    for (let i = 1; i < parts.length; i++) {
+      if (files.has(parts.slice(0, i).join('/'))) fail('release-path-conflict', { path: name });
+    }
+  }
+}
+function regular(file, directory = false) {
+  const stat = fs.lstatSync(file);
+  if (directory ? !stat.isDirectory() : !stat.isFile() || stat.nlink !== 1) {
+    fail('release-unsafe-entry', { path: file });
+  }
+  return stat;
+}
+function physicalRoot(root) {
+  if (typeof root !== 'string' || !path.isAbsolute(root)) fail('invalid-arguments', { argument: 'absolute path required' }, 2);
+  regular(root, true);
+  return fs.realpathSync(root);
+}
+function safeFile(root, relative) {
+  validatePath(relative);
+  const parts = relative.split('/');
+  for (let i = 1; i < parts.length; i++) regular(path.join(root, ...parts.slice(0, i)), true);
+  const file = path.join(root, ...parts);
+  regular(file);
+  return file;
+}
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (error) {
+    if (error instanceof SyntaxError) fail('invalid-json', { path: file });
+    throw error;
+  }
+}
+function treeFiles(root, relative = '', npmInstall = false) {
+  regular(path.join(root, relative), true);
+  const files = [];
+  for (const name of fs.readdirSync(path.join(root, relative)).sort()) {
+    const rel = relative ? `${relative}/${name}` : name;
+    validatePath(rel);
+    const stat = fs.lstatSync(path.join(root, rel));
+    if (stat.isDirectory()) {
+      // npm generates these launch shims after unpacking. Mutable install sources
+      // may contain them; immutable releases never do, and capture never copies them.
+      if (npmInstall && rel === 'node_modules/.bin') continue;
+      files.push(...treeFiles(root, rel, npmInstall));
+    }
+    else { regular(path.join(root, rel)); files.push(rel); }
+  }
+  validatePaths(files);
+  return files.sort();
+}
+function packageMetadata(root) {
+  const pkg = readJson(safeFile(root, 'package.json'));
+  if (pkg.name !== 'devlyn-cli' || !VERSION.test(pkg.version) || typeof pkg.engines?.node !== 'string') {
+    fail('release-schema', { field: 'package.json' }, 3);
+  }
+  return pkg;
+}
+
+function generatedArtifacts(root) {
+  const pkg = packageMetadata(root);
+  const template = fs.readFileSync(safeFile(root, 'CLAUDE.md'), 'utf8').replace(/\r\n/g, '\n');
+  const agents = fs.readFileSync(safeFile(root, 'AGENTS.md'), 'utf8').replace(/\r\n/g, '\n');
+  if (template !== agents || /<!-- devlyn:instructions:(?:begin|end)/.test(template)) {
+    fail('release-template-mismatch', {});
+  }
+  const outputs = new Map();
+  const put = (name, bytes, executable = false) => outputs.set(name, { bytes: Buffer.from(bytes), executable });
+  put(DEFAULTS, sessionDefaults(template));
+  put('harness/CLAUDE.md', managedBlock(template));
+  put('harness/AGENTS.md', managedBlock(template));
+  const plugin = { name: 'devlyn', version: pkg.version, description: 'Devlyn harness skills', skills: './skills/' };
+  put('native/claude/.claude-plugin/plugin.json', jsonBytes(plugin));
+  put('native/codex/plugins/devlyn/.codex-plugin/plugin.json', jsonBytes(plugin));
+  put('native/codex/.agents/plugins/marketplace.json', jsonBytes({
+    name: `devlyn-harness-v${pkg.version.replace(/\./g, '-')}`,
+    plugins: [{ name: 'devlyn', source: { source: 'local', path: './plugins/devlyn' } }],
+  }));
+  for (const skill of CORE) {
+    const source = `config/skills/${skill}`;
+    for (const relative of treeFiles(path.join(root, source))) {
+      // Python bytecode and OS metadata are not release inputs.
+      if (relative.split('/').includes('__pycache__') || /(?:^|\/)(?:\.DS_Store|Thumbs\.db)$|\.pyc$/.test(relative)) continue;
+      const name = `${source}/${relative}`;
+      const file = safeFile(root, name);
+      const bytes = outputs.get(name)?.bytes || fs.readFileSync(file);
+      const executable = name === DEFAULTS ? false : Boolean(fs.statSync(file).mode & 0o111);
+      for (const mirror of ['native/claude', 'native/codex/plugins/devlyn']) put(`${mirror}/skills/${skill}/${relative}`, bytes, executable);
+    }
+  }
+  return outputs;
+}
+
+function checkGenerated(root) {
+  const expected = generatedArtifacts(root);
+  for (const [name, { bytes, executable }] of expected) {
+    const file = safeFile(root, name);
+    if (!fs.readFileSync(file).equals(bytes) || (process.platform !== 'win32' && Boolean(fs.statSync(file).mode & 0o111) !== executable)) {
+      fail('release-generated-mismatch', { path: name });
+    }
+  }
+  const actual = ['harness', 'native'].flatMap((dir) => treeFiles(path.join(root, dir)).map((name) => `${dir}/${name}`));
+  if (actual.some((name) => !expected.has(name))) fail('release-generated-mismatch', { path: 'unlisted generated file' });
+  return expected.size;
+}
+
+function metadata(root) {
+  const pkg = packageMetadata(root);
+  return {
+    schemaVersion: 1, package: 'devlyn-cli', version: pkg.version,
+    principles: { defaults: DEFAULTS, memory: { claude: 'harness/CLAUDE.md', agents: 'harness/AGENTS.md' },
+      sourceBlockSha256: sha256(managedBody(fs.readFileSync(safeFile(root, 'CLAUDE.md'), 'utf8'))) },
+    skills: { root: 'config/skills', names: CORE.slice(0, 2), support: '_shared',
+      claudePlugin: 'native/claude', codexMarketplace: 'native/codex' },
+    stateCompat: {
+      loopManifest: { read: [1, 1], write: 1 }, addRecord: { read: [1, 1], write: 1 },
+      taskPacket: { inspect: [1, 2], execute: [1, 2], write: 2 },
+      queueBinding: { read: [1, 1], write: 1 },
+      submission: { read: [1, 1], write: 1 }, review: { read: [1, 1], write: 1 },
+      acceptanceResult: { read: [1, 1], write: 1 }, invocationReceipt: { read: [1, 1], write: 1 },
+      legacyFormats: ['completion-receipt-unversioned', 'direct-acceptance-unversioned',
+        'expected-contract-unversioned', 'engines-config-unversioned', 'queue-markdown-inspect-only'],
+    },
+    requires: { node: pkg.engines.node, python: '>=3.11', git: true, windowsGitBash: true, githubDelivery: 'gh' },
+  };
+}
+
+function writeArtifact(root, name, bytes, executable) {
+  const parts = name.split('/');
+  for (let i = 1; i < parts.length; i++) {
+    const dir = path.join(root, ...parts.slice(0, i));
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir);
+    regular(dir, true);
+  }
+  const file = path.join(root, name);
+  if (fs.lstatSync(file, { throwIfNoEntry: false })) regular(file);
+  fs.writeFileSync(file, bytes);
+  fs.chmodSync(file, executable ? 0o755 : 0o644);
+}
+
+function buildRelease(root = PACKAGE_ROOT) {
+  root = physicalRoot(root);
+  // npm omits links from its inventory; reject them before that omission can hide an input.
+  for (const dir of ['bin', 'config', 'optional-skills']) treeFiles(path.join(root, dir));
+  const outputs = generatedArtifacts(root);
+  // Generated roots are package-owned. Validate before removing stale mirror files.
+  for (const dir of ['harness', 'native']) {
+    if (fs.lstatSync(path.join(root, dir), { throwIfNoEntry: false })) {
+      treeFiles(path.join(root, dir));
+      fs.rmSync(path.join(root, dir), { recursive: true });
+    }
+  }
+  for (const [name, { bytes, executable }] of outputs) writeArtifact(root, name, bytes, executable);
+  // npm's own inventory includes the exact bundled dependency closure and pack exclusions.
+  const npmCli = process.env.npm_execpath || (process.platform === 'win32'
+    ? path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js') : null);
+  const result = spawnSync(npmCli ? process.execPath : 'npm', [
+    ...(npmCli ? [npmCli] : []), 'pack', '--dry-run', '--ignore-scripts', '--json',
+  ], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  if (result.error || result.status !== 0) fail('release-pack-failed', { detail: result.error?.message || result.stderr.trim() });
+  const packed = JSON.parse(result.stdout)[0];
+  const names = packed.files.map((file) => file.path).filter((name) => name !== 'release.json').sort();
+  validatePaths(names);
+  const pkg = packageMetadata(root);
+  for (const dependency of pkg.bundleDependencies) {
+    if (!names.includes(`node_modules/${dependency}/package.json`)) fail('release-missing-dependency', { dependency });
+  }
+  const modes = new Map(packed.files.map((file) => [file.path, Boolean(file.mode & 0o111)]));
+  const manifest = { ...metadata(root), files: names.map((name) => ({
+    path: name, sha256: sha256(fs.readFileSync(safeFile(root, name))), executable: modes.get(name),
+  })) };
+  manifest.digest = { algorithm: 'sha256', value: manifestDigest(manifest) };
+  writeArtifact(root, 'release.json', jsonBytes(manifest), false);
+  return { manifestPath: path.join(root, 'release.json'), version: manifest.version,
+    digest: manifest.digest.value, fileCount: manifest.files.length };
+}
+
+// npm runs prepack in the source checkout and leaves its outputs there; postpack removes them, so a
+// checkout never carries a release.json that would make its own skills read as a release.
+function cleanGenerated(root = PACKAGE_ROOT) {
+  root = physicalRoot(root);
+  for (const name of ['harness', 'native', 'release.json']) {
+    const file = path.join(root, name);
+    const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+    if (!stat) continue;
+    if (stat.isSymbolicLink() || !(stat.isDirectory() || stat.isFile())) fail('release-unsafe-entry', { path: file });
+    fs.rmSync(file, { recursive: true });
+  }
+}
+
+function checkNpmShims(root, files) {
+  const dir = path.join(root, 'node_modules/.bin');
+  if (!fs.lstatSync(dir, { throwIfNoEntry: false })) return;
+  regular(dir, true);
+  const names = new Set(files.map((file) => file.path));
+  const targets = new Map();
+  for (const file of files) {
+    if (!/^node_modules\/(?:@[^/]+\/)?[^/]+\/package\.json$/.test(file.path)) continue;
+    const pkg = readJson(safeFile(root, file.path));
+    const bins = typeof pkg.bin === 'string' ? { [pkg.name.split('/').at(-1)]: pkg.bin } : pkg.bin || {};
+    for (const [name, relative] of Object.entries(bins)) {
+      validatePath(name);
+      if (name.includes('/') || typeof relative !== 'string') fail('release-schema', { field: 'dependency bin' }, 3);
+      const target = path.posix.normalize(`${path.posix.dirname(file.path)}/${relative}`);
+      validatePath(target);
+      if (!names.has(target)) fail('release-file-list-mismatch', { path: target });
+      for (const shim of [name, `${name}.cmd`, `${name}.ps1`]) {
+        if (!targets.has(shim)) targets.set(shim, new Set());
+        targets.get(shim).add(path.join(root, target));
+      }
+    }
+  }
+  for (const name of fs.readdirSync(dir)) {
+    const file = path.join(dir, name);
+    const stat = fs.lstatSync(file);
+    if (!targets.has(name)) fail('release-file-list-mismatch', { path: `node_modules/.bin/${name}` });
+    if (stat.isSymbolicLink()) {
+      if (!targets.get(name).has(path.resolve(dir, fs.readlinkSync(file)))) fail('release-unsafe-entry', { path: file });
+    } else regular(file); // Windows shims are regular files; never execute or copy them.
+  }
+}
+
+function verifyRelease(root, { npmInstall = false } = {}) {
+  root = physicalRoot(root);
+  const manifest = readJson(safeFile(root, 'release.json'));
+  if (!manifest || manifest.schemaVersion !== 1 || manifest.package !== 'devlyn-cli'
+      || !VERSION.test(manifest.version) || manifest.digest?.algorithm !== 'sha256'
+      || !SHA256.test(manifest.digest?.value) || !Array.isArray(manifest.files)
+      || !manifest.files.every((f) => f && typeof f.path === 'string' && SHA256.test(f.sha256) && typeof f.executable === 'boolean')) {
+    fail('release-schema', { path: 'release.json' }, 3);
+  }
+  const names = manifest.files.map((file) => file.path);
+  validatePaths([...names, 'release.json']);
+  if (canonical(names) !== canonical([...names].sort())) fail('release-schema', { field: 'files order' }, 3);
+  if (manifestDigest(manifest) !== manifest.digest.value) fail('release-digest-mismatch', { path: 'release.json' });
+  const actual = treeFiles(root, '', npmInstall).filter((name) => name !== 'release.json');
+  if (canonical(actual) !== canonical(names)) fail('release-file-list-mismatch', {});
+  for (const file of manifest.files) {
+    const full = safeFile(root, file.path);
+    if (sha256(fs.readFileSync(full)) !== file.sha256) fail('release-file-digest-mismatch', { path: file.path });
+    // Windows has no POSIX execute bit; its declared mode is retained in the digest.
+    if (process.platform !== 'win32' && Boolean(fs.statSync(full).mode & 0o111) !== file.executable) {
+      fail('release-mode-mismatch', { path: file.path });
+    }
+  }
+  if (npmInstall) checkNpmShims(root, manifest.files);
+  const { files, digest, ...declared } = manifest;
+  if (canonical(declared) !== canonical(metadata(root))) fail('release-schema', { field: 'metadata' }, 3);
+  checkGenerated(root);
+  return { release: { package: 'devlyn-cli', version: manifest.version, digest: digest.value, root }, valid: true };
+}
+
+function materializeRelease(source, store) {
+  const verified = verifyRelease(source, { npmInstall: true }).release;
+  if (!path.isAbsolute(store)) fail('invalid-arguments', { argument: 'absolute store required' }, 2);
+  // Check every existing store component before mkdir; never write through a store link.
+  const missing = [];
+  let parent = path.resolve(store);
+  while (!fs.lstatSync(parent, { throwIfNoEntry: false })) { missing.push(parent); parent = path.dirname(parent); }
+  regular(parent, true);
+  for (let dir = parent; dir !== path.dirname(dir); dir = path.dirname(dir)) regular(dir, true);
+  for (const dir of missing.reverse()) { fs.mkdirSync(dir, { recursive: true }); regular(dir, true); }
+  store = physicalRoot(store);
+  const packageDir = path.join(store, 'devlyn-cli');
+  fs.mkdirSync(packageDir, { recursive: true });
+  regular(packageDir, true);
+  const target = path.join(packageDir, verified.version);
+  const existing = () => {
+    const release = verifyRelease(target).release;
+    if (release.digest !== verified.digest) fail('release-version-conflict', { version: release.version }, 3);
+    return { release, created: false };
+  };
+  if (fs.lstatSync(target, { throwIfNoEntry: false })) return existing();
+  const temp = fs.mkdtempSync(path.join(packageDir, `.${verified.version}-`));
+  try {
+    const manifest = readJson(safeFile(verified.root, 'release.json'));
+    for (const file of [...manifest.files, { path: 'release.json', executable: false }]) {
+      writeArtifact(temp, file.path, fs.readFileSync(safeFile(verified.root, file.path)), file.executable);
+    }
+    const captured = verifyRelease(temp).release;
+    if (captured.digest !== verified.digest) fail('release-source-changed', {}, 3);
+    try { fs.renameSync(temp, target); }
+    catch (error) {
+      if (['EEXIST', 'ENOTEMPTY', 'EPERM', 'EACCES'].includes(error.code) && fs.existsSync(target)) return existing();
+      throw error;
+    }
+    return { release: { ...captured, root: target }, created: true };
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+function options(args, definitions) {
+  try { return parseArgs({ args, options: { json: { type: 'boolean' }, ...definitions }, strict: true }).values; }
+  catch (error) { fail('invalid-arguments', { detail: error.message }, 2); }
+}
+function releaseCommand(args) {
+  const opts = options(args, Object.fromEntries(['build', 'verify', 'materialize', 'root', 'source', 'store']
+    .map((key) => [key, { type: ['build', 'verify', 'materialize'].includes(key) ? 'boolean' : 'string' }])));
+  const actions = ['build', 'verify', 'materialize'].filter((key) => opts[key]);
+  const allowed = { build: ['build', 'json'], verify: ['verify', 'root', 'json'], materialize: ['materialize', 'source', 'store', 'json'] };
+  if (actions.length !== 1 || Object.keys(opts).some((key) => !allowed[actions[0]].includes(key))
+      || (opts.verify && !opts.root) || (opts.materialize && (!opts.source || !opts.store))) fail('invalid-arguments', {}, 2);
+  if (opts.build) return buildRelease();
+  if (opts.verify) return verifyRelease(opts.root);
+  return materializeRelease(opts.source, opts.store);
+}
+function runJson(action) {
+  try { process.stdout.write(JSON.stringify({ schemaVersion: 1, ok: true, data: action() }) + '\n'); }
+  catch (error) {
+    const reason = error instanceof HarnessError ? error.reason
+      : { code: 'operation-failed', params: { detail: error.message, ...(error.code ? { systemCode: error.code } : {}) } };
+    process.stderr.write(`${reason.code}: ${JSON.stringify(reason.params)}\n`);
+    process.stdout.write(JSON.stringify({ schemaVersion: 1, ok: false, error: reason }) + '\n');
+    process.exitCode = error instanceof HarnessError ? error.exitCode : 1;
+  }
+}
+
+module.exports = { buildRelease, cleanGenerated, verifyRelease, materializeRelease, checkGenerated,
+  sha256, manifestDigest, physicalRoot, HarnessError, fail,
+  options, releaseCommand, runJson };

package/bin/skill-history.json

@@ -18,6 +18,7 @@
       "161cb4f1b27a9f81ae1e96af6ff596399c8936578a11d601108a89cbdeea241d",
       "196afa14871099a9afc4e484b00e8d8ccd928dba79db95a6a8776f58c8e78c39",
       "1c1e5e44ff704b1b8791fabcad79a4158d8cd2f024569c1685ec3b185a98fbcc",
+      "20ac702b463f3eaa07fd6686d5209aed7993773504e35896fc732f7e653ec6cd",
       "20bfec10dcec9a06701827a6a39faf3495f970f659f1e941cbfb62e880a0649c",
       "20e11efa7b27dcd30b5550ba5e0e2e07df9ac522a76445a594803a0e29b2e13d",
       "21723943c52573124ce3c74e9090a8ae7d7c9ecdeb78fdfa52b89c45ff1b3374",
@@ -42,6 +43,7 @@
       "3be2ec1243eb28f779b170e469dfb65555a92dc08b3d927b8973cbd49308125d",
       "3c58989be2f943896810ef709fb115171420a918dfaadc43ea47940fa8ebc7ed",
       "3c81c575cc43d70488865b440204cb399091405d9b7f81dbf047a32d3d5ac045",
+      "3cb043970432281f3c2c3c7ec813c4721221ca18ff227e94ef204f2ef2178044",
       "3cd398df22e666fdd2e0f253c5a7464bca62bceefe3737d28a5ef95b75cb3a33",
       "3e39fbe29d0bd607f4ad940f4ca40f9abf82d468e418d0362fb0fd4fa6812475",
       "3e5135877e733f1dcff3b747444228f5eece7cb047956c87a3af02a485cfaad9",
@@ -90,6 +92,7 @@
       "7a0f6c692bd1f74759d44f1a145899c157e1787635db546ea8a192461421e353",
       "7ca704d818bf9c044fed59fdd4107bd0463f9b0514d44729003e3e52aa796353",
       "7e915cc7307af694e326c7f75cf831d187edd965f38d870323cd50f0f01a564b",
+      "7f5f9f318f465b01c573fa521922a218e0973056a53053d262ca6ffb84dda145",
       "800543bb9d1f8b90a7c077f072aa45364a0136d3c4e9b7acddcdbc30d63eb0c8",
       "823e497e01870123d4e73c8dac7472e161b5ffa2f6181ddcba71fcb829096948",
       "83b6d37fcacc086a09b9c3eddfff2263bfef23f8fabf8d8833a7c9f9fb6186c5",
@@ -147,6 +150,7 @@
       "db867d1fd98058bb20e41e942abd95f08fbaa9465928025f69f0a0308fa71514",
       "dd0bfdfd2db0b5f9ddef75d1b9ce3247698739fc551d292366dccd506fef6a36",
       "ddb0c8dac58e95298330ab54e4d1fe4a108c968d9af713f267b4f8f4c6808507",
+      "de4f504265e960cb8d81752e9ae922f664790ee026b4454f1b07252d1a6282a4",
       "e0a305cf3bf47c8bc357195d4d50b0f6177069e870c33040c258c93edae68646",
       "e115205a744fef918a59d1b3a601df09a8b6df1d3e60613b9e8b87240929f8d8",
       "e41013abf5e17445ef83a86974ac1de77beaa61e484e1916577ecc64bb34c220",
@@ -354,6 +358,7 @@
       "d6433bf0f96dd9dd485c3623885255738654674b3e23cfcc1a2cfd24f3cda96e",
       "db8d921aabf0d04811b55465a3757c62c4b39631aebaf6eecc994ca241cfbe56",
       "e25da746dc37b2e82c658a28d9481fd69741151045683eee2119582ddaf731cd",
+      "e47a2ce766ae81fa0870e0a8dfbfe737311de69ce620e92217abbe4c532e3c8b",
       "e929f76c15349f1b9bc1e84e0a3e9e48e916168d79270e0f4a36ea8eab9b5388",
       "f2243cc4150e225961825f6097b0cf38166c291dcf58127516ceee841f7ed4c8",
       "fa536198d539a3c85f54dda74d0d78716ac6e6849e733bdadecc8605511eac37",

package/config/skills/_shared/adapters/omp.md

@@ -1,3 +1,6 @@
 # oh-my-pi adapter
 
+executor: no
+
 Engine `omp`, the oh-my-pi CLI.
+Stub: model-call execution and failure handling have not been qualified.

package/config/skills/_shared/harness-store.py

@@ -0,0 +1,201 @@
+"""Release identity and queue resource checks. Readers never write or create locks.
+
+The release verifier is CLI-1's bin/release.js, not a second manifest verifier.
+A Codex projection has .devlyn-harness-projection.json at its plugin root:
+{schemaVersion: 1, release: ReleaseRef, source: "native/codex/plugins/devlyn"}.
+Its complete regular-file tree (except that marker) must match that release subtree.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+
+PROJECTION = ".devlyn-harness-projection.json"
+CODEX_SOURCE = "native/codex/plugins/devlyn"
+
+
+class HarnessError(Exception):
+    pass
+
+
+def require(condition, message):
+    if not condition:
+        raise HarnessError(message)
+
+
+def read_json(path):
+    try:
+        return json.loads(Path(path).read_bytes())
+    except (OSError, ValueError) as exc:
+        raise HarnessError(f"{path}: {exc}") from exc
+
+
+def file_identity(path):
+    path = Path(path)
+    info = path.lstat()
+    require(path.is_file() and not path.is_symlink() and info.st_nlink == 1, f"not a regular resource: {path}")
+    return {"path": str(path), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()}
+
+
+def release_ref(value):
+    require(isinstance(value, dict) and set(value) == {"package", "version", "digest", "root"}
+            and value["package"] == "devlyn-cli"
+            and all(isinstance(value[k], str) and value[k] and "\0" not in value[k] for k in ("version", "digest", "root"))
+            and re.fullmatch(r"[a-f0-9]{64}", value["digest"]) and Path(value["root"]).is_absolute(), "malformed release reference")
+    return value
+
+
+def verify_release(root):
+    root = Path(root)
+    script = "const r=require(process.argv[1]);r.runJson(()=>r.verifyRelease(process.argv[2]));"
+    result = subprocess.run(["node", "-e", script, str(root / "bin/release.js"), str(root)], capture_output=True, text=True, encoding="utf-8")
+    require(result.returncode == 0, f"release verification failed: {root}: {result.stderr.strip()}")
+    try:
+        release = release_ref(json.loads(result.stdout)["data"]["release"])
+    except (KeyError, ValueError, TypeError) as exc:
+        raise HarnessError(f"invalid release verifier result: {root}: {exc}") from exc
+    manifest = read_json(root / "release.json")
+    defaults = file_identity(root / manifest["principles"]["defaults"])
+    return {"schemaVersion": 1, "release": release, "defaults": defaults}
+
+
+def walk_error(error):
+    raise error  # os.walk otherwise silently skips unreadable projection directories.
+
+
+def resolve(skills):
+    """Resolve only this invoking skill's real ancestry; never search another install."""
+    skill = (Path(skills) / "devlyn-ideate").resolve()
+    for parent in (skill, *skill.parents):
+        marker = parent / PROJECTION
+        if marker.exists() or marker.is_symlink():
+            file_identity(marker)
+            projection = read_json(marker)
+            require(isinstance(projection, dict) and set(projection) == {"schemaVersion", "release", "source"}
+                    and type(projection["schemaVersion"]) is int and projection["schemaVersion"] == 1
+                    and projection["source"] == CODEX_SOURCE, f"malformed projection: {marker}")
+            ref = release_ref(projection["release"])
+            binding = verify_release(ref["root"])
+            require(binding["release"] == ref, f"projection release changed: {marker}")
+            source = Path(ref["root"]) / CODEX_SOURCE
+            require(skill == parent / "skills/devlyn-ideate", f"unexpected projection skill: {skill}")
+            expected = {p.relative_to(source) for p in source.rglob("*") if p.is_file()}
+            actual = set()
+            for directory, dirs, files in os.walk(parent, onerror=walk_error):
+                for name in dirs:
+                    require(not (Path(directory) / name).is_symlink(), f"projection directory link: {directory}/{name}")
+                for name in files:
+                    file = Path(directory) / name
+                    if file == marker:
+                        continue
+                    rel = file.relative_to(parent)
+                    actual.add(rel)
+                    require(rel in expected and file_identity(file)["sha256"] == file_identity(source / rel)["sha256"]
+                            and (os.name == "nt" or bool(file.stat().st_mode & 0o111) == bool((source / rel).stat().st_mode & 0o111)),
+                            f"projection resource changed: {file}")
+            require(actual == expected, f"projection file list changed: {parent}")
+            return binding
+        manifest = parent / "release.json"
+        if (manifest.exists() or manifest.is_symlink()) and skill in [parent / p / "devlyn-ideate" for p in
+                ("config/skills", "native/claude/skills", CODEX_SOURCE + "/skills")]:
+            return verify_release(parent)
+    return None
+
+
+def read_binding(common):
+    path = Path(common) / "devlyn-loops/harness.json"
+    if not path.exists() and not path.is_symlink():
+        return None
+    file_identity(path)
+    binding = read_json(path)
+    require(isinstance(binding, dict) and set(binding) == {"schemaVersion", "release", "defaults"}
+            and type(binding["schemaVersion"]) is int and binding["schemaVersion"] == 1, f"incompatible queue binding: {path}")
+    release_ref(binding["release"])
+    resource(binding["defaults"])
+    return binding
+
+
+def resource(value):
+    require(isinstance(value, dict) and set(value) == {"path", "sha256"}
+            and isinstance(value["path"], str) and "\0" not in value["path"] and Path(value["path"]).is_absolute()
+            and isinstance(value["sha256"], str) and re.fullmatch(r"[a-f0-9]{64}", value["sha256"]), "malformed resource binding")
+
+
+def recovery_argv(binding, argv):
+    return [sys.executable, str(Path(binding["release"]["root"]) / "config/skills/devlyn-ideate/scripts/queue.py"), *argv]
+
+
+def check_binding(binding, invoking):
+    if binding is None:
+        return
+    require(invoking is not None and binding["release"] == invoking["release"], "queue-release-mismatch")
+    require(binding == invoking, "queue defaults changed; restore the bound release")
+
+
+def packet_schema(packet):
+    require(isinstance(packet, dict), "task packet must be an object")
+    version = packet.get("schema_version", 1)
+    require(type(version) is int and version in (1, 2), f"incompatible task packet version: {version!r}")
+    if version == 1:
+        return
+    require("harness" in packet and isinstance(packet.get("methodology"), dict), "malformed packet v2 harness/methodology")
+    methodology = packet["methodology"]
+    require(set(methodology) == {"defaults", "projectInstructions"} and isinstance(methodology["projectInstructions"], list),
+            "malformed packet v2 methodology")
+    for entry in methodology["projectInstructions"]:
+        resource(entry)
+    if packet["harness"] is None:
+        defaults = methodology["defaults"]
+        require(packet.get("workerPrompt") is None and (defaults is None or (isinstance(defaults, dict) and defaults.get("source") == "skill")),
+                "legacy packet has release resources")
+        if defaults is not None:
+            resource({k: v for k, v in defaults.items() if k != "source"})
+        return
+    release_ref(packet["harness"])
+    defaults = methodology["defaults"]
+    require(isinstance(defaults, dict) and defaults.get("source") == "release", "packet has no verified release defaults source")
+    resource({k: v for k, v in defaults.items() if k != "source"})
+    resource(packet.get("workerPrompt"))
+
+
+def verify_packet(packet, path, skills):
+    packet_schema(packet)
+    if packet.get("schema_version", 1) == 1:
+        return  # Preserve v1 execution without upgrading its resources.
+    receipt = packet.get("receipt")
+    require(isinstance(receipt, str) and "\0" not in receipt and Path(receipt).is_absolute()
+            and Path(receipt).name == "receipt.json" and Path(receipt).parent.parent.name == "devlyn-completion"
+            and Path(receipt) == Path(path).with_name("receipt.json"),
+            "malformed packet receipt path")
+    binding = read_binding(Path(receipt).parent.parent.parent)
+    if packet["harness"] is None:
+        require(binding is None, "bound task packet has no harness/defaults source")
+        # An unbound installation's own defaults change with its normal updates: never gate acceptance or delivery on
+        # their bytes (queue.py checks only their presence, before a spawn).
+        return
+    require(binding is not None, "packet queue binding is missing; restore harness.json")
+    invoking = resolve(skills)
+    ref = packet["harness"]
+    require(invoking is not None and invoking["release"] == ref,
+            f"packet-release-mismatch; use {Path(ref['root']) / 'config/skills/devlyn-ideate/scripts/queue.py'}")
+    check_binding(binding, invoking)
+    defaults = {"source": "release", **binding["defaults"]}
+    require(packet["methodology"]["defaults"] == defaults, "packet defaults differ from queue binding")
+    expected_runner = [str(Path(ref["root"]) / "config/skills/devlyn-ideate/scripts/acceptance.py"),
+                       "run", "--packet", str(path)]
+    require(isinstance(packet.get("runner"), list) and packet["runner"][1:] == expected_runner, "packet runner differs from bound release")
+    prompt = packet["workerPrompt"]
+    require(prompt["path"] == str(Path(path).parent / "worker-prompt.md") and file_identity(prompt["path"]) == prompt,
+            "worker prompt changed or missing; restore the bound resource")
+    for entry in packet["methodology"]["projectInstructions"]:
+        name = Path(entry["path"]).name
+        require(name in ("CLAUDE.md", "AGENTS.md") and entry["path"] == str(Path(packet["worktree"]) / name),
+                "project instruction path escapes packet worktree")
+        committed = subprocess.run(["git", "-C", packet["worktree"], "cat-file", "blob", f"{packet['inputs_sha']}:{name}"], capture_output=True)
+        require(committed.returncode == 0 and hashlib.sha256(committed.stdout).hexdigest() == entry["sha256"],
+                f"project instruction differs from inputs commit: {name}")