morphisms 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,45 @@
+Morphisms Proprietary Preview License
+
+Licensor: Blake Sims / Zen AI Tutoring
+Software: Morphisms preview binaries and packaged materials
+
+1. Preview grant. You may install and use the Software locally for personal use,
+   internal business use, and commercial evaluation.
+
+2. No redistribution. You may not copy, sell, sublicense, republish, mirror,
+   upload, package, or otherwise redistribute the Software or its binaries to
+   any third party without written permission from the Licensor.
+
+3. No reverse engineering. You may not reverse engineer, decompile, disassemble,
+   modify, bypass technical limits in, or create derivative binary builds of the
+   Software, except where applicable law expressly forbids this restriction.
+
+4. No hosted service resale. You may not provide the Software as a hosted or
+   managed service for others, or use it to offer substantially similar workflow
+   runtime services, without written permission from the Licensor.
+
+5. Ownership. The Software is licensed, not sold. The Licensor retains all right,
+   title, and interest in the Software and related intellectual property.
+
+6. Preview software. The Software is a preview. It may change, break, lose
+   compatibility, be withdrawn, or stop working at any time. Features, APIs,
+   data formats, and availability are not guaranteed.
+
+7. Feedback. If you provide feedback, suggestions, or bug reports, you grant the
+   Licensor permission to use them without restriction or compensation.
+
+8. Termination. This license terminates automatically if you violate its terms.
+   After termination, you must stop using the Software and delete all copies in
+   your possession or control.
+
+9. No warranty. THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE," WITHOUT
+   WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+   NON-INFRINGEMENT.
+
+10. Limitation of liability. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE
+    LICENSOR WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
+    CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR FOR LOST PROFITS, LOST
+    DATA, BUSINESS INTERRUPTION, OR PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES.
+
+If you want rights not granted here, contact Blake Sims / Zen AI Tutoring.

package/bin/mor-workbench.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+const { forwardSpawn } = require('../lib/forward');
+forwardSpawn('mor-workbench', process.argv.slice(2));

package/bin/mor.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+const { forwardSync } = require('../lib/forward');
+process.exit(forwardSync('mor', process.argv.slice(2)));

package/bin/morphisms.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const { main } = require('../lib/cli');
+
+Promise.resolve(main(process.argv.slice(2))).then((code) => {
+  if (typeof code === 'number') process.exit(code);
+}).catch((error) => {
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});

package/lib/cli.js

@@ -0,0 +1,28 @@
+const pkg = require('../package.json');
+const { initCommand } = require('./init');
+const { updateCommand } = require('./update');
+const { workbenchCommand } = require('./workbench');
+
+function help() {
+  console.log(`Morphisms ${pkg.version}\n\nUsage:\n  morphisms init\n  morphisms workbench [--port N]\n  morphisms update\n  morphisms --version`);
+}
+
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === '-h' || command === '--help') {
+    help();
+    return 0;
+  }
+  if (command === '-v' || command === '--version' || command === 'version') {
+    console.log(pkg.version);
+    return 0;
+  }
+  if (command === 'init') return initCommand(rest);
+  if (command === 'update') return updateCommand(rest);
+  if (command === 'workbench') return workbenchCommand(rest);
+  console.error(`unknown morphisms command: ${command}`);
+  help();
+  return 1;
+}
+
+module.exports = { main };

package/lib/files.js

@@ -0,0 +1,49 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function exists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copyFileNoClobber(src, dest, notes) {
+  if (exists(dest)) {
+    notes.push(`skip existing ${dest}`);
+    return false;
+  }
+  ensureDir(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+  notes.push(`wrote ${dest}`);
+  return true;
+}
+
+function copyTreeNoClobber(srcDir, destDir, notes) {
+  if (!exists(srcDir)) {
+    throw new Error(`template directory is missing: ${srcDir}`);
+  }
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const src = path.join(srcDir, entry.name);
+    const dest = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyTreeNoClobber(src, dest, notes);
+    } else if (entry.isFile()) {
+      copyFileNoClobber(src, dest, notes);
+    }
+  }
+}
+
+function writeJsonNoClobber(dest, value, notes) {
+  if (exists(dest)) {
+    notes.push(`skip existing ${dest}`);
+    return false;
+  }
+  ensureDir(path.dirname(dest));
+  fs.writeFileSync(dest, `${JSON.stringify(value, null, 2)}\n`);
+  notes.push(`wrote ${dest}`);
+  return true;
+}
+
+module.exports = { copyFileNoClobber, copyTreeNoClobber, ensureDir, exists, writeJsonNoClobber };

package/lib/forward.js

@@ -0,0 +1,45 @@
+const { spawn, spawnSync } = require('node:child_process');
+const { printPlatformError, resolvePlatformBinary } = require('./platform');
+
+function forwardSync(binaryName, argv) {
+  let binaryPath;
+  try {
+    binaryPath = resolvePlatformBinary(binaryName);
+  } catch (error) {
+    printPlatformError(error);
+    return 1;
+  }
+  const result = spawnSync(binaryPath, argv, { stdio: 'inherit' });
+  if (result.error) {
+    console.error(`failed to run ${binaryName}: ${result.error.message}`);
+    return 1;
+  }
+  if (result.signal) {
+    return 1;
+  }
+  return typeof result.status === 'number' ? result.status : 1;
+}
+
+function forwardSpawn(binaryName, argv) {
+  let binaryPath;
+  try {
+    binaryPath = resolvePlatformBinary(binaryName);
+  } catch (error) {
+    printPlatformError(error);
+    process.exit(1);
+  }
+  const child = spawn(binaryPath, argv, { stdio: 'inherit' });
+  child.on('error', (error) => {
+    console.error(`failed to run ${binaryName}: ${error.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(typeof code === 'number' ? code : 1);
+  });
+}
+
+module.exports = { forwardSpawn, forwardSync };

package/lib/init.js

@@ -0,0 +1,190 @@
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+const { copyFileNoClobber, copyTreeNoClobber, ensureDir, exists, writeJsonNoClobber } = require('./files');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const TEMPLATES_ROOT = path.join(PACKAGE_ROOT, 'templates');
+const CONTRACT_TEMPLATE_DIR = path.join(TEMPLATES_ROOT, 'contract');
+const DEFAULT_PORT = 4400;
+const DISTRO_ALIAS = 'issues';
+const VIEWER_REGISTRY_GITIGNORE_ENTRY = '.morphisms-contract/viewer-workspaces.json';
+
+function resolveContractSource(repoRoot, contractDir) {
+  if (exists(path.join(contractDir, 'distro.yaml'))) return path.relative(repoRoot, contractDir) || '.';
+  const morFile = path.join(contractDir, 'contract.mor');
+  if (exists(morFile)) return path.relative(repoRoot, morFile);
+  return path.relative(repoRoot, contractDir) || '.';
+}
+
+function createPrompt() {
+  if (!process.stdin.isTTY) {
+    const answers = fs.readFileSync(0, 'utf8').split(/\r?\n/);
+    let index = 0;
+    return {
+      question(text) {
+        process.stdout.write(text);
+        return Promise.resolve((answers[index++] || '').trim());
+      },
+      close() {},
+    };
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    question(text) {
+      return new Promise((resolve) => rl.question(text, (answer) => resolve(answer.trim())));
+    },
+    close() {
+      rl.close();
+    },
+  };
+}
+
+async function askYesNo(prompt, label, defaultValue) {
+  const suffix = defaultValue ? '[Y/n]' : '[y/N]';
+  const answer = (await prompt.question(`${label} ${suffix} `)).toLowerCase();
+  if (!answer) return defaultValue;
+  return answer === 'y' || answer === 'yes';
+}
+
+async function askPort(prompt) {
+  for (;;) {
+    const answer = await prompt.question(`Workbench port [${DEFAULT_PORT}] `);
+    if (!answer) return DEFAULT_PORT;
+    const port = Number(answer);
+    if (Number.isInteger(port) && port > 0 && port < 65536) return port;
+    console.log('Please enter a TCP port from 1 to 65535.');
+  }
+}
+
+function runMor(args, cwd, extraEnv = {}) {
+  console.log(`$ mor ${args.join(' ')}`);
+  const result = spawnSync('mor', args, { cwd, stdio: 'inherit', env: { ...process.env, ...extraEnv } });
+  if (result.error) {
+    throw new Error(`failed to run mor ${args.join(' ')}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`mor ${args.join(' ')} exited with ${result.status}`);
+  }
+}
+
+function ensureGitignoreEntry(repoRoot, entry, notes) {
+  const gitignorePath = path.join(repoRoot, '.gitignore');
+  const existing = exists(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+  const hasEntry = existing.split(/\r?\n/).some((line) => line.trim() === entry);
+  if (hasEntry) {
+    notes.push(`gitignore already contains ${entry}`);
+    return false;
+  }
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  const header = existing.includes('# Morphisms local machine state') ? '' : '# Morphisms local machine state\n';
+  fs.writeFileSync(gitignorePath, `${existing}${prefix}${header}${entry}\n`);
+  notes.push(`added ${entry} to .gitignore`);
+  return true;
+}
+
+function installManifest(repoRoot, flavors, notes) {
+  const manifestPath = path.join(TEMPLATES_ROOT, 'manifest.json');
+  if (!exists(manifestPath)) {
+    notes.push('skip missing templates/manifest.json');
+    return;
+  }
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  if (!Array.isArray(manifest)) {
+    throw new Error('templates/manifest.json must be an array');
+  }
+  for (const entry of manifest) {
+    validateManifestEntry(entry);
+    if (entry.when === 'claude' && !flavors.claude) continue;
+    if (entry.when === 'agent' && !flavors.agent) continue;
+    const src = path.join(TEMPLATES_ROOT, entry.src);
+    const dest = resolveManifestDest(repoRoot, entry.dest);
+    if (!path.resolve(src).startsWith(TEMPLATES_ROOT + path.sep)) {
+      throw new Error(`manifest src escapes templates/: ${entry.src}`);
+    }
+    if (!exists(src)) {
+      notes.push(`skip missing template ${entry.src}`);
+      continue;
+    }
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyTreeNoClobber(src, dest, notes);
+    } else if (stat.isFile()) {
+      copyFileNoClobber(src, dest, notes);
+    }
+  }
+}
+
+function validateManifestEntry(entry) {
+  if (!entry || typeof entry !== 'object') throw new Error('manifest entries must be objects');
+  if (typeof entry.src !== 'string' || entry.src.includes('..') || path.isAbsolute(entry.src)) {
+    throw new Error(`invalid manifest src: ${entry.src}`);
+  }
+  if (typeof entry.dest !== 'string' || !entry.dest.includes('{repo}')) {
+    throw new Error(`invalid manifest dest: ${entry.dest}`);
+  }
+  if (!['claude', 'agent', 'always'].includes(entry.when)) {
+    throw new Error(`invalid manifest when: ${entry.when}`);
+  }
+}
+
+function resolveManifestDest(repoRoot, destTemplate) {
+  const resolvedRepo = path.resolve(repoRoot);
+  const replaced = destTemplate.replaceAll('{repo}', resolvedRepo);
+  const resolvedDest = path.resolve(replaced);
+  if (resolvedDest !== resolvedRepo && !resolvedDest.startsWith(resolvedRepo + path.sep)) {
+    throw new Error(`manifest dest escapes repository: ${destTemplate}`);
+  }
+  return resolvedDest;
+}
+
+async function initCommand() {
+  const repoRoot = path.resolve(process.cwd());
+  const detectedClaude = exists(path.join(repoRoot, '.claude'));
+  const detectedAgent = exists(path.join(repoRoot, '.agent'));
+  const prompt = createPrompt();
+  const notes = [];
+  try {
+    console.log('Morphisms init will install the starter contract and local agent-facing files.');
+    const claudeDefault = detectedClaude || !detectedAgent;
+    const agentDefault = detectedAgent;
+    const claude = await askYesNo(prompt, `Install Claude Code files${detectedClaude ? ' (detected .claude/)' : ''}?`, claudeDefault);
+    const agent = await askYesNo(prompt, `Install .agent files${detectedAgent ? ' (detected .agent/)' : ''}?`, agentDefault);
+    const port = await askPort(prompt);
+
+    const contractDest = path.join(repoRoot, '.morphisms-contract', 'issues_front_half');
+    copyTreeNoClobber(CONTRACT_TEMPLATE_DIR, contractDest, notes);
+    const contractSource = resolveContractSource(repoRoot, contractDest);
+
+    const viewerRegistry = path.join(repoRoot, '.morphisms-contract', 'viewer-workspaces.json');
+    const registryEnv = { MOR_VIEWER_REGISTRY_PATH: viewerRegistry };
+    runMor(['setup', contractSource, '--workspace', '.', '--alias', DISTRO_ALIAS, '--activate'], repoRoot, registryEnv);
+    runMor(['viewer', 'register', '.'], repoRoot, registryEnv);
+    ensureGitignoreEntry(repoRoot, VIEWER_REGISTRY_GITIGNORE_ENTRY, notes);
+    runMor(['runtime', 'verify'], repoRoot);
+
+    installManifest(repoRoot, { claude, agent }, notes);
+    writeJsonNoClobber(path.join(repoRoot, '.morphisms-contract', 'config.json'), {
+      schema_version: 'morphisms.init-config/1',
+      workbench_port: port,
+      contract: contractSource,
+      distro_alias: DISTRO_ALIAS,
+      store_alias: 'issue',
+      runtime_db: `.mor/${DISTRO_ALIAS}.sqlite3`,
+      viewer_registry: '.morphisms-contract/viewer-workspaces.json',
+      agent_flavors: { claude, agent },
+    }, notes);
+
+    for (const note of notes) console.log(note);
+    console.log('Next step: open Claude Code here and say: "start morphisms onboarding".');
+    return 0;
+  } catch (error) {
+    console.error(`morphisms init failed: ${error.message}`);
+    return 1;
+  } finally {
+    prompt.close();
+  }
+}
+
+module.exports = { ensureGitignoreEntry, initCommand, installManifest, resolveContractSource, resolveManifestDest, validateManifestEntry };

package/lib/platform.js

@@ -0,0 +1,40 @@
+const SUPPORTED_PLATFORMS = [
+  { platform: 'linux', arch: 'x64', packageName: '@morphisms/bin-linux-x64' },
+  { platform: 'darwin', arch: 'arm64', packageName: '@morphisms/bin-darwin-arm64' },
+  { platform: 'darwin', arch: 'x64', packageName: '@morphisms/bin-darwin-x64' },
+];
+
+function platformPackageName(platform = process.platform, arch = process.arch) {
+  const match = SUPPORTED_PLATFORMS.find((entry) => entry.platform === platform && entry.arch === arch);
+  return match ? match.packageName : null;
+}
+
+function supportedList() {
+  return SUPPORTED_PLATFORMS.map((entry) => `${entry.platform}-${entry.arch} (${entry.packageName})`).join(', ');
+}
+
+function resolvePlatformBinary(binaryName) {
+  const packageName = platformPackageName();
+  if (!packageName) {
+    throw new Error(`Morphisms does not ship a binary package for ${process.platform}-${process.arch}. Supported platforms: ${supportedList()}.`);
+  }
+  try {
+    return require.resolve(`${packageName}/bin/${binaryName}`);
+  } catch (error) {
+    const wrapped = new Error(`Morphisms could not find the optional platform package ${packageName} for ${process.platform}-${process.arch}. Reinstall with optional dependencies enabled (npm install -g morphisms) or use one of the supported platforms: ${supportedList()}.`);
+    wrapped.cause = error;
+    throw wrapped;
+  }
+}
+
+function printPlatformError(error) {
+  console.error(error && error.message ? error.message : String(error));
+}
+
+module.exports = {
+  SUPPORTED_PLATFORMS,
+  platformPackageName,
+  printPlatformError,
+  resolvePlatformBinary,
+  supportedList,
+};

package/lib/update.js

@@ -0,0 +1,45 @@
+const https = require('node:https');
+const pkg = require('../package.json');
+
+const REGISTRY_URL = 'https://registry.npmjs.org/morphisms';
+
+function fetchRegistry() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(REGISTRY_URL, { headers: { accept: 'application/json' }, timeout: 5000 }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`registry returned HTTP ${res.statusCode}`));
+        return;
+      }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('registry request timed out')));
+    req.on('error', reject);
+  });
+}
+
+async function updateCommand() {
+  try {
+    const data = await fetchRegistry();
+    const tags = data['dist-tags'] || {};
+    const latest = tags.latest || 'unknown';
+    const beta = tags.beta || 'unknown';
+    const installed = pkg.version;
+    const hint = installed === latest || installed === beta ? 'up to date for a published tag' : 'newer version may be available';
+    console.log(`morphisms ${installed} installed; npm latest ${latest}; beta ${beta}; ${hint}.`);
+  } catch (error) {
+    console.log(`morphisms ${pkg.version} installed; update check unavailable (${error.message}).`);
+  }
+  return 0;
+}
+
+module.exports = { REGISTRY_URL, updateCommand };

package/lib/workbench.js

@@ -0,0 +1,120 @@
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const { exists } = require('./files');
+
+const WORKBENCH_LAUNCH = {
+  source: '.morphisms-contract/issues_front_half/contract.mor',
+  host: '127.0.0.1',
+  runtimeDb: '.mor/issues.sqlite3',
+  workspaceRegistry: '.morphisms-contract/viewer-workspaces.json',
+};
+
+function parseWorkbenchArgs(argv) {
+  let port;
+  let workspaceRegistry = process.env.MORPHISMS_WORKBENCH_REGISTRY || undefined;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--port') {
+      const value = argv[++i];
+      if (!value) throw new Error('--port requires a value');
+      port = parsePort(value);
+    } else if (arg.startsWith('--port=')) {
+      port = parsePort(arg.slice('--port='.length));
+    } else if (arg === '--workspace-registry') {
+      workspaceRegistry = argv[++i];
+      if (!workspaceRegistry) throw new Error('--workspace-registry requires a value');
+    } else if (arg.startsWith('--workspace-registry=')) {
+      workspaceRegistry = arg.slice('--workspace-registry='.length);
+      if (!workspaceRegistry) throw new Error('--workspace-registry requires a value');
+    } else {
+      throw new Error(`unknown workbench argument: ${arg}`);
+    }
+  }
+  return { port, workspaceRegistry };
+}
+
+function parsePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`invalid port: ${value}`);
+  }
+  return port;
+}
+
+function readConfig(repoRoot) {
+  const configPath = path.join(repoRoot, '.morphisms-contract', 'config.json');
+  if (!exists(configPath)) return {};
+  try {
+    delete require.cache[require.resolve(configPath)];
+    return require(configPath);
+  } catch (_) {
+    return {};
+  }
+}
+
+function configuredPort(repoRoot) {
+  const config = readConfig(repoRoot);
+  if (!config.workbench_port) return 4400;
+  try {
+    return parsePort(String(config.workbench_port));
+  } catch (_) {
+    return 4400;
+  }
+}
+
+function configuredSource(repoRoot) {
+  const config = readConfig(repoRoot);
+  return typeof config.contract === 'string' && config.contract ? config.contract : WORKBENCH_LAUNCH.source;
+}
+
+function configuredRegistry(repoRoot) {
+  const config = readConfig(repoRoot);
+  return typeof config.viewer_registry === 'string' && config.viewer_registry ? config.viewer_registry : WORKBENCH_LAUNCH.workspaceRegistry;
+}
+
+function configuredRuntimeDb(repoRoot) {
+  const config = readConfig(repoRoot);
+  return typeof config.runtime_db === 'string' && config.runtime_db ? config.runtime_db : WORKBENCH_LAUNCH.runtimeDb;
+}
+
+function buildWorkbenchArgv(repoRoot, options = {}) {
+  const launchPort = options.port || configuredPort(repoRoot);
+  const workspaceRegistry = options.workspaceRegistry || configuredRegistry(repoRoot);
+  return [
+    configuredSource(repoRoot),
+    '--serve',
+    `${WORKBENCH_LAUNCH.host}:${launchPort}`,
+    '--runtime-db',
+    configuredRuntimeDb(repoRoot),
+    '--workspace-registry',
+    workspaceRegistry,
+  ];
+}
+
+function workbenchCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseWorkbenchArgs(argv);
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const port = parsed.port || configuredPort(process.cwd());
+  const childArgv = buildWorkbenchArgv(process.cwd(), parsed);
+  console.log(`Starting Morphisms Workbench at http://127.0.0.1:${port}/#workbench`);
+  const child = spawn('mor-workbench', childArgv, { stdio: 'inherit' });
+  child.on('error', (error) => {
+    console.error(`failed to run mor-workbench: ${error.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(typeof code === 'number' ? code : 1);
+  });
+  return undefined;
+}
+
+module.exports = { WORKBENCH_LAUNCH, buildWorkbenchArgv, parseWorkbenchArgs, workbenchCommand };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "morphisms",
+  "version": "0.1.0-beta.1",
+  "description": "Morphisms workflow runtime shim and onboarding wizard",
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "morphisms": "bin/morphisms.js",
+    "mor": "bin/mor.js",
+    "mor-workbench": "bin/mor-workbench.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "LICENSE",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "optionalDependencies": {
+    "@morphisms/bin-linux-x64": "0.1.0-beta.1"
+  }
+}

package/templates/README.md

@@ -0,0 +1,21 @@
+# Morphisms npm templates
+
+This directory is installed by the `morphisms` npm shim and consumed by `morphisms init`.
+
+`manifest.json` is the copy mechanism for agent-facing files authored by the P3 content worker. It is a JSON array of entries:
+
+```json
+{
+  "src": "claude/skills/morphisms/SKILL.md",
+  "dest": "{repo}/.claude/skills/morphisms/SKILL.md",
+  "when": "claude"
+}
+```
+
+- `src` is a relative path under `templates/`.
+- `dest` is an absolute destination after replacing `{repo}` with the initialized repository root.
+- `when` is `claude`, `agent`, or `always` and is filtered by the wizard's flavor answers.
+- The starter contract is not listed here; `init` copies `templates/contract/` directly into `{repo}/.morphisms-contract/issues_front_half/`.
+- Build releases populate `templates/contract/` from `contracts/starter/issues_front_half/`.
+
+P3 should append real skill/instruction/onboarding entries to `manifest.json` and add the corresponding files under this directory.