wtf-p 0.7.4 → 0.8.0

package/bin/lib/clio-registration.js

@@ -5,9 +5,9 @@ const path = require('path');
 const { createTargetGuard, resolveOwnedPath, sha256Buffer } = require('./ownership');
 
 // Clio owns integrity, provenance, drift and enable/disable for an installed
-// plugin. WTF-P owns two much smaller things: the exact bytes it publishes
-// (its v2 receipt) and the guarantee that the tree handed to Clio is the
-// generated bundle and nothing else.
+// plugin or extension. WTF-P owns two much smaller things: the exact bytes it
+// publishes (its v2 receipt) and the guarantee that each tree handed to Clio
+// is the generated package and nothing else.
 function treeFiles(root) {
   const files = new Map();
   function visit(directory) {
@@ -37,10 +37,11 @@ function scopeOptions(targetDir, options) {
   return { ...options, cwd, scope: project ? 'project' : 'user' };
 }
 
-function generatedBundle(root) {
+function generatedBundle(root, target = 'portable-plugin') {
   const inventoryPath = path.join(root, '.wtfp-generated.json');
+  if (!fs.existsSync(inventoryPath)) return null;
   const inventory = JSON.parse(fs.readFileSync(inventoryPath, 'utf8'));
-  if (inventory.schema !== 'wtfp.generated-adapter/v1' || inventory.target !== 'portable-plugin') {
+  if (inventory.schema !== 'wtfp.generated-adapter/v1' || inventory.target !== target) {
     return null;
   }
   const expected = new Map(inventory.files.map(file => [file.path, file.sha256]));
@@ -108,42 +109,110 @@ function installedListEntry(stdout, targetDir, native, scope) {
   return matches[0];
 }
 
-// Registration is what WTF-P is responsible for. Whether the operator has the
-// plugin switched on is Clio's state and their decision, so it is reported,
+function installedExtensionEntry(stdout, targetDir, native, scope) {
+  const listing = JSON.parse(stdout);
+  if (!listing || !Array.isArray(listing.extensions)) {
+    throw new Error('Clio extensions list did not return an extensions array');
+  }
+  for (const entry of listing.extensions) {
+    if (!installedRecord(entry)) throw new Error('Clio extensions list returned a malformed installed extension');
+  }
+  const matches = listing.extensions.filter(entry => entry.id === native.id && entry.scope === scope &&
+    sameRoot(entry.rootPath, path.join(targetDir, native.source)));
+  if (matches.length > 1) throw new Error('Clio extensions list returned duplicate installed extension identities');
+  return matches[0];
+}
+
+// The two Clio packages WTF-P installs, plugin first. Each is its own Clio
+// install with its own lifecycle command, generated inventory and checks.
+function clioPackages(native) {
+  const plugin = {
+    noun: 'plugin', command: 'library', id: native.id, source: native.source, inventory: 'portable-plugin',
+    deferral: 'Clio activation requires an intact generated bundle without extra or modified files',
+    list: () => ['library', 'list', '--kind', 'plugin', '--json'],
+    listed: (stdout, targetDir, scope) => installedListEntry(stdout, targetDir, native, scope),
+    // `inspect` returns the installed record for the explicitly selected scope.
+    verify: scope => ['library', 'inspect', native.id, `--${scope}`, '--json'],
+    verified: (stdout, targetDir, scope) => verifiedEntry(stdout, targetDir, native, scope)
+  };
+  if (!native.extension) return [plugin];
+  const extension = native.extension;
+  const listed = (stdout, targetDir, scope) => installedExtensionEntry(stdout, targetDir, extension, scope);
+  return [plugin, {
+    noun: 'extension', command: 'extensions', id: extension.id, source: extension.source, inventory: 'clio-extension',
+    deferral: 'Clio extension activation requires an intact generated extension without extra or modified files',
+    list: scope => ['extensions', 'list', `--${scope}`, '--json'],
+    listed,
+    verify: scope => ['extensions', 'list', `--${scope}`, '--json'],
+    verified: listed
+  }];
+}
+
+// Registration is what WTF-P is responsible for. Whether the operator has a
+// package switched on is Clio's state and their decision, so it is reported,
 // never asserted and never changed.
 function registered(entry) {
   return Boolean(entry) && entry.valid === true &&
     Array.isArray(entry.diagnostics) && entry.diagnostics.length === 0;
 }
 
-function disabledNotice(native, scope) {
-  return `Clio reports ${native.id} as installed but disabled. WTF-P does not change that preference; run clio-coder library enable ${native.id} --${scope} to switch it back on.`;
+function disabledNotice(pkg, scope) {
+  return `Clio reports ${pkg.id} as installed but disabled. WTF-P does not change that preference; run clio-coder ${pkg.command} enable ${pkg.id} --${scope} to switch it back on.`;
 }
 
+// Install the plugin, then the extension. A failure in the second compensates
+// the first, and the returned compensator undoes both in reverse order.
 function activateClio(targetDir, native, suppliedOptions) {
   const options = scopeOptions(targetDir, suppliedOptions);
+  const activated = [];
+  try {
+    for (const pkg of clioPackages(native)) {
+      const result = activatePackage(targetDir, pkg, options);
+      activated.push(result);
+      if (result.status !== 'registered') break;
+    }
+  } catch (error) {
+    const failures = activated.reverse().flatMap(result => typeof result.rollback === 'function' ? result.rollback() : []);
+    if (failures.length) error.nativeRollbackFailures = [...(error.nativeRollbackFailures || []), ...failures];
+    throw error;
+  }
+  if (activated.length === 1) return activated[0];
+  const last = activated[activated.length - 1];
+  const notices = activated.map(result => result.notice).filter(Boolean);
+  return {
+    status: last.status, executable: 'clio-coder',
+    ...(last.reason ? { reason: last.reason } : {}),
+    results: activated.flatMap(result => result.results),
+    ...(notices.length ? { notice: notices.join(' ') } : {}),
+    rollback() {
+      return [...activated].reverse().flatMap(result => typeof result.rollback === 'function' ? result.rollback() : []);
+    },
+    commit() {
+      const warnings = activated.map(result => typeof result.commit === 'function' ? result.commit() : undefined).filter(Boolean);
+      return warnings.length ? warnings.join('; ') : undefined;
+    }
+  };
+}
+
+function activatePackage(targetDir, pkg, options) {
   const { execute, environment } = options;
   const guard = createTargetGuard(targetDir);
-  const root = resolveOwnedPath(targetDir, native.source, guard);
+  const root = resolveOwnedPath(targetDir, pkg.source, guard);
   const publishedFiles = treeFiles(root);
-  const expected = generatedBundle(root);
+  const expected = generatedBundle(root, pkg.inventory);
   if (!expected || !sameTree(expected, publishedFiles)) {
-    return {
-      status: 'deferred',
-      reason: 'Clio activation requires an intact generated bundle without extra or modified files',
-      results: []
-    };
+    return { status: 'deferred', reason: pkg.deferral, results: [] };
   }
 
   const results = [];
-  const priorList = execute('clio-coder', ['library', 'list', '--kind', 'plugin', '--json'], environment, options);
+  const priorList = execute('clio-coder', pkg.list(options.scope), environment, options);
   if (priorList.status === 'unavailable') return { status: 'unavailable', executable: 'clio-coder', results };
   results.push(priorList);
-  const priorEntry = installedListEntry(priorList.stdout, targetDir, native, options.scope);
+  const priorEntry = pkg.listed(priorList.stdout, targetDir, options.scope);
   if (registered(priorEntry)) {
     return {
       status: 'registered', executable: 'clio-coder', results,
-      ...(priorEntry.enabled === false ? { notice: disabledNotice(native, options.scope) } : {})
+      ...(priorEntry.enabled === false ? { notice: disabledNotice(pkg, options.scope) } : {})
     };
   }
 
@@ -152,7 +221,7 @@ function activateClio(targetDir, native, suppliedOptions) {
   // until the receipt is durable lets a failed registration put the previous
   // installation back before the file transaction rolls it back.
   const staging = fs.mkdtempSync(path.join(path.dirname(root), '.wtfp-staged-'));
-  const source = path.join(staging, 'wtfp');
+  const source = path.join(staging, pkg.id);
   fs.renameSync(root, source);
   let finished = false;
 
@@ -163,15 +232,15 @@ function activateClio(targetDir, native, suppliedOptions) {
         if (!sameTree(publishedFiles, treeFiles(root))) {
           throw new Error('Clio content changed concurrently; recovery tree preserved');
         }
-        const removal = execute('clio-coder', ['library', 'remove', native.id, `--${options.scope}`, '--json'], environment,
+        const removal = execute('clio-coder', [pkg.command, 'remove', pkg.id, `--${options.scope}`, '--json'], environment,
           { ...options, allowAlreadyAbsent: true });
         results.push(removal);
         if (removal.status === 'unavailable') throw new Error('Clio became unavailable during rollback');
       }
       if (fs.existsSync(root)) throw new Error('Clio rollback did not remove the replacement');
-      const after = execute('clio-coder', ['library', 'list', '--kind', 'plugin', '--json'], environment, options);
+      const after = execute('clio-coder', pkg.list(options.scope), environment, options);
       results.push(after);
-      if (after.status === 'unavailable' || installedListEntry(after.stdout, targetDir, native, options.scope)) {
+      if (after.status === 'unavailable' || pkg.listed(after.stdout, targetDir, options.scope)) {
         throw new Error('Clio rollback did not clear the replacement registration');
       }
       fs.renameSync(source, root);
@@ -184,22 +253,22 @@ function activateClio(targetDir, native, suppliedOptions) {
   }
 
   try {
-    const installation = execute('clio-coder', ['library', 'install', source, `--${options.scope}`, '--json'], environment, options);
+    const installation = execute('clio-coder', [pkg.command, 'install', source, `--${options.scope}`, '--json'], environment, options);
     results.push(installation);
     if (installation.status === 'unavailable') throw new Error('Clio became unavailable during installation');
-    const inspected = execute('clio-coder', ['library', 'inspect', native.id, `--${options.scope}`, '--json'], environment, options);
+    const inspected = execute('clio-coder', pkg.verify(options.scope), environment, options);
     results.push(inspected);
     if (inspected.status === 'unavailable') throw new Error('Clio became unavailable during verification');
-    const entry = verifiedEntry(inspected.stdout, targetDir, native, options.scope);
+    const entry = pkg.verified(inspected.stdout, targetDir, options.scope);
     if (!registered(entry) || !sameTree(publishedFiles, treeFiles(root))) {
-      throw new Error('Clio did not report the exact WTF-P plugin as installed and valid with zero diagnostics');
+      throw new Error(`Clio did not report the exact WTF-P ${pkg.noun} as installed and valid with zero diagnostics`);
     }
     if (priorEntry && priorEntry.enabled !== entry.enabled) {
-      throw new Error('Clio installation changed the existing WTF-P enabled preference');
+      throw new Error(`Clio installation changed the existing WTF-P ${pkg.noun} enabled preference`);
     }
     return {
       status: 'registered', executable: 'clio-coder', results, rollback,
-      ...(entry.enabled === false ? { notice: disabledNotice(native, options.scope) } : {}),
+      ...(entry.enabled === false ? { notice: disabledNotice(pkg, options.scope) } : {}),
       commit() {
         // Only the private held copy is removed; Clio owns its installed tree.
         finished = true;
@@ -217,27 +286,49 @@ function activateClio(targetDir, native, suppliedOptions) {
   }
 }
 
+// Remove the extension, then the plugin, each only when the receipt proves it.
+// `ownedFiles` maps receipt paths below the target to their published hashes.
 function deactivateClio(targetDir, native, suppliedOptions) {
   const options = scopeOptions(targetDir, suppliedOptions);
+  const removed = [];
+  for (const pkg of clioPackages(native).reverse()) {
+    const prefix = `${pkg.source}/`;
+    const ownedFiles = options.ownedFiles && new Map([...options.ownedFiles]
+      .filter(([file]) => file.startsWith(prefix))
+      .map(([file, hash]) => [file.slice(prefix.length), hash]));
+    const result = deactivatePackage(targetDir, pkg, { ...options, ownedFiles });
+    if (result.status === 'unavailable') return result;
+    removed.push(result);
+  }
+  if (removed.length === 1) return removed[0];
+  const deferred = removed.find(result => result.status === 'deferred');
+  const results = removed.flatMap(result => result.results);
+  if (deferred) return { status: 'deferred', reason: deferred.reason, results };
+  return removed.some(result => result.status === 'unregistered')
+    ? { status: 'unregistered', executable: 'clio-coder', results }
+    : { status: 'not-required', results };
+}
+
+function deactivatePackage(targetDir, pkg, options) {
   const { execute, environment } = options;
   const guard = createTargetGuard(targetDir);
-  const listing = execute('clio-coder', ['library', 'list', '--kind', 'plugin', '--json'], environment, options);
+  const listing = execute('clio-coder', pkg.list(options.scope), environment, options);
   if (listing.status === 'unavailable') return { status: 'unavailable', executable: 'clio-coder', results: [] };
-  if (!installedListEntry(listing.stdout, targetDir, native, options.scope)) {
+  if (!pkg.listed(listing.stdout, targetDir, options.scope)) {
     return { status: 'not-required', results: [listing] };
   }
 
   // Native removal is recursive. Run it only when the receipt proves that every
   // file below the installed root is one WTF-P published and nobody changed.
-  const root = resolveOwnedPath(targetDir, native.source, guard);
+  const root = resolveOwnedPath(targetDir, pkg.source, guard);
   const ownedFiles = options.ownedFiles;
   if (!ownedFiles || !sameTree(treeFiles(root), ownedFiles)) {
-    return { status: 'deferred', reason: 'Clio native removal would include unowned or modified plugin files', results: [listing] };
+    return { status: 'deferred', reason: `Clio native removal would include unowned or modified ${pkg.noun} files`, results: [listing] };
   }
-  const result = execute('clio-coder', ['library', 'remove', native.id, `--${options.scope}`, '--json'], environment, options);
+  const result = execute('clio-coder', [pkg.command, 'remove', pkg.id, `--${options.scope}`, '--json'], environment, options);
   if (result.status === 'unavailable') return { status: 'unavailable', executable: 'clio-coder', results: [listing] };
-  const after = execute('clio-coder', ['library', 'list', '--kind', 'plugin', '--json'], environment, options);
-  if (after.status === 'unavailable' || fs.existsSync(root) || installedListEntry(after.stdout, targetDir, native, options.scope)) {
+  const after = execute('clio-coder', pkg.list(options.scope), environment, options);
+  if (after.status === 'unavailable' || fs.existsSync(root) || pkg.listed(after.stdout, targetDir, options.scope)) {
     throw new Error('Clio removal did not clear WTF-P content and registration');
   }
   return { status: 'unregistered', executable: 'clio-coder', results: [listing, result, after] };

package/bin/lib/manifest.js

@@ -67,8 +67,9 @@ const MANIFEST = {
       source: 'marketplaces/wtfp'
     }
   },
-  // Clio consumes the canonical Agent Plugins bundle through its own plugin
-  // lifecycle. There is no second WTF-P packaging for this host.
+  // Clio consumes the canonical Agent Plugins bundle through its plugin
+  // lifecycle and the desk through its extension lifecycle: two packages, two
+  // Clio installs, one WTF-P receipt.
   clio: {
     name: 'Clio Coder',
     configDirEnv: 'CLIO_CODER_CONFIG_DIR',
@@ -80,6 +81,12 @@ const MANIFEST = {
         src: path.join(ROOT, 'vendors', 'plugin'),
         dest: 'plugins/wtfp',
         type: 'dir'
+      },
+      {
+        id: 'extension',
+        src: path.join(ROOT, 'vendors', 'clio-extension'),
+        dest: 'extensions/wtfp',
+        type: 'dir'
       }
     ],
     discovery: {
@@ -89,7 +96,8 @@ const MANIFEST = {
     native: {
       kind: 'clio-plugin',
       id: 'wtfp',
-      source: 'plugins/wtfp'
+      source: 'plugins/wtfp',
+      extension: { id: 'wtfp', source: 'extensions/wtfp' }
     }
   },
   codex: {

package/bin/uninstall.js

@@ -780,9 +780,10 @@ async function uninstall(runtime, options, out) {
       vendorConfig.native,
       { ...(vendorKey === 'clio' && plan.receipt.scope === 'project'
         ? { scope: 'project', cwd: path.dirname(targetDir) } : {}),
+      // Receipt paths below the target; Clio checks each package root against them.
       ownedFiles: new Map(plan.items
-        .filter(item => item.path.startsWith(`${vendorConfig.native.source}/`) && item.state === 'unchanged')
-        .map(item => [item.path.slice(vendorConfig.native.source.length + 1), item.entry.sha256])) }
+        .filter(item => item.state === 'unchanged')
+        .map(item => [item.path, item.entry.sha256])) }
     );
     if (nativeRemoval.status === 'unavailable' && !options.hasQuiet) {
       out.warn(`${nativeRemoval.executable} is unavailable; removing the WTF-P-owned staging files without changing the client's native registry.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtf-p",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable, evidence-grounded academic writing workflows (papers, proposals, posters, presentations) for Clio Coder, Claude Code, Codex, GitHub Copilot CLI, OpenCode, Antigravity CLI, and Gemini CLI.",
   "bin": {
     "wtfp": "bin/install.js",

package/vendors/antigravity/.wtfp-generated.json

@@ -2,7 +2,7 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "antigravity",
-  "sourceHash": "e6be36fb1d333a4a58170b6ea1066f3ccc8306e0b86b164e0eabca2aaa5f168a",
+  "sourceHash": "c2e93ea50f26a53402f100fe9157834a3841748eebd8cc212648cd615738278d",
   "files": [
     {
       "path": "actions/add-todo.json",
@@ -362,7 +362,7 @@
     },
     {
       "path": "plugin.json",
-      "sha256": "198d10a8df114d382642abc9f200ef30826f5ed28c5698b8d33030f9d78349a1"
+      "sha256": "9898153f5524eeea64715c41f2c6fe68f90a312e7f2c2ed08485a448da5ff989"
     },
     {
       "path": "project/README.md",

package/vendors/antigravity/plugin.json

@@ -1,5 +1,5 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "wtfp",
-  "description": "Portable academic research and writing workflows (WTF-P 0.7.4)."
+  "description": "Portable academic research and writing workflows (WTF-P 0.8.0)."
 }

package/vendors/claude/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "WTF-P evidence-grounded academic workflow plugin.",
-    "version": "0.7.4"
+    "version": "0.8.0"
   },
   "plugins": [
     {
       "name": "wtfp",
       "source": "./",
       "description": "Portable academic research and writing workflows.",
-      "version": "0.7.4",
+      "version": "0.8.0",
       "author": {
         "name": "akougkas"
       },

package/vendors/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable academic research and writing workflows with stable wtfp actions.",
   "author": {
     "name": "akougkas",

package/vendors/claude/.wtfp-generated.json

@@ -2,15 +2,15 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "claude",
-  "sourceHash": "9f59216dd7c84459a7ac468a2e4b53afbc747b2b159d830bff660a6f6e784562",
+  "sourceHash": "21f3c778ba3384293f5b8d107edbda1d09b927b4c47550cd348ebc51c21921f9",
   "files": [
     {
       "path": ".claude-plugin/marketplace.json",
-      "sha256": "f0bd66a2076c4301269f4077e673b43449c4f43a76fd6974890ceb7ba065d628"
+      "sha256": "993e95f1576cf98d92e562f75ff126b6a2832f73ca27610de05145e802605f9c"
     },
     {
       "path": ".claude-plugin/plugin.json",
-      "sha256": "06d93546610469be4076195c9c4ff95ddde74910ccbbb3f8de0a627677249876"
+      "sha256": "9b8391fc30f1b454b4795cb94c5de6b0ef6fb7accc1546221c3239f2b7ffeaae"
     },
     {
       "path": "actions/add-todo.json",
@@ -306,7 +306,7 @@
     },
     {
       "path": "ai.iowarp.clio/prompts/wtfp/help.md",
-      "sha256": "54b10ac95db9428017fc9511c753dcc9820c701fbeb8e2b1557e0559692d9727"
+      "sha256": "921118815b4cce6cac7a74388191265d56eeb68378096997f112f08de525a0e6"
     },
     {
       "path": "ai.iowarp.clio/prompts/wtfp/insert-section.md",
@@ -574,7 +574,7 @@
     },
     {
       "path": "plugin.json",
-      "sha256": "b5427e46af32758733b35fafc5757a4ec5dbdd6d03d48a0489187907907b9bf8"
+      "sha256": "5cd012f727ce4dfd33819323a828d78e64ca2a1d09e11e289dcb51648cb23502"
     },
     {
       "path": "project/README.md",

package/vendors/claude/ai.iowarp.clio/prompts/wtfp/help.md

@@ -4,7 +4,7 @@ display-only: true
 ---
 
 ```text
-WTF-P 0.7.4 on Clio Coder: evidence-grounded academic writing
+WTF-P 0.8.0 on Clio Coder: evidence-grounded academic writing
 
 Start here
   /wtfp:new-paper [input]

package/vendors/claude/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable, evidence-grounded academic research and writing workflows.",
   "author": {
     "name": "akougkas"