@planu/cli 4.12.3 → 4.14.1

package/dist/engine/safety/obsolete-lock-guard.js

@@ -0,0 +1,31 @@
+import { lstat } from 'node:fs/promises';
+function assertSafeLockPathSegment(value, label) {
+    if (value === '.' || value === '..' || !/^[A-Za-z0-9_-][A-Za-z0-9._-]{0,511}$/u.test(value)) {
+        throw new Error(`[Planu] Invalid lock ${label} for filesystem compatibility inspection`);
+    }
+}
+export function assertSafeLockScopeId(scopeId) {
+    assertSafeLockPathSegment(scopeId, 'scopeId');
+}
+export function assertSafeLockResourceId(resourceId) {
+    assertSafeLockPathSegment(resourceId, 'resourceId');
+}
+/**
+ * Refuse mixed-version access when an older file-lock authority is present.
+ * The file is never removed here because path-based unlink cannot be made ABA-safe.
+ */
+export async function assertNoObsoleteFileLock(path, resource) {
+    try {
+        await lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    const error = new Error(`[Planu] Incompatible file-lock protocol detected for ${resource}. Stop every older Planu process before upgrading; the lock was preserved for safe manual recovery.`);
+    error.code = 'INCOMPATIBLE_LOCK_PROTOCOL';
+    throw error;
+}
+//# sourceMappingURL=obsolete-lock-guard.js.map

package/dist/engine/safety/transaction.js

@@ -1,5 +1,6 @@
 // SPEC-094 AC-2 + AC-10: Transaction with auto-rollback and error classification
 import { randomUUID } from 'node:crypto';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
 export class SafetyTransactionError extends Error {
     code;
     severity;
@@ -63,9 +64,8 @@ export class Transaction {
                 await step.undoFn();
             }
             catch (undoErr) {
-                /* v8 ignore next -- undoErr is always Error in practice */
-                const msg = undoErr instanceof Error ? undoErr.message : String(undoErr);
-                console.warn(`[Transaction] Undo failed for step "${stepName}": ${msg}`);
+                // reliability-optional: TRANSACTION_UNDO — rollback continues through remaining steps
+                reportClassifiedDegradation('TRANSACTION_UNDO', undoErr);
             }
         }
     }

package/dist/engine/sandbox/index.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/sandbox/index.ts — Public API for sandbox runner (SPEC-742)
 import { detectRunner } from './runner-detect.js';
 import { runWithBwrap } from './runner-bwrap.js';
@@ -29,7 +30,7 @@ export async function runInSandbox(command, args, options) {
             return runWithBwrap(command, args, options);
         case 'sandbox-exec':
             return runWithSandboxExec(command, args, options);
-        case 'docker':
+        case technologyValue('technology-docker-d548c5'):
             return runWithDocker(command, args, options);
     }
 }

package/dist/engine/sandbox/runner-detect.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/sandbox/runner-detect.ts — Capability probe for sandbox runners (SPEC-742)
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -48,9 +49,9 @@ export async function detectRunner() {
         }
     }
     // Docker — CI fallback (any platform)
-    const hasDocker = await isAvailable('docker', ['info']);
+    const hasDocker = await isAvailable(technologyValue('technology-docker-d548c5'), ['info']);
     if (hasDocker) {
-        cachedRunner = 'docker';
+        cachedRunner = technologyValue('technology-docker-d548c5');
         return cachedRunner;
     }
     cachedRunner = null;

package/dist/engine/sandbox/runner-docker.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/sandbox/runner-docker.ts — Docker CI fallback sandbox runner (SPEC-742)
 import { spawn } from 'node:child_process';
 import { sanitizeEnv } from './env-sanitizer.js';
@@ -37,7 +38,7 @@ export async function runWithDocker(command, args, options) {
     return new Promise((resolve) => {
         let stdout = '';
         let stderr = '';
-        const child = spawn('docker', dockerArgs, {
+        const child = spawn(technologyValue('technology-docker-d548c5'), dockerArgs, {
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         child.stdout.on('data', (chunk) => {
@@ -52,7 +53,7 @@ export async function runWithDocker(command, args, options) {
                 stdout,
                 stderr,
                 durationMs: Date.now() - startMs,
-                runner: 'docker',
+                runner: technologyValue('technology-docker-d548c5'),
             });
         });
         child.on('error', (err) => {
@@ -61,7 +62,7 @@ export async function runWithDocker(command, args, options) {
                 stdout,
                 stderr: stderr + '\n' + err.message,
                 durationMs: Date.now() - startMs,
-                runner: 'docker',
+                runner: technologyValue('technology-docker-d548c5'),
             });
         });
     });

package/dist/engine/scan-project/module-discoverer.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/scan-project/module-discoverer.ts — Detects module boundaries in a project (SPEC-134)
 // Language-agnostic: supports monorepo, package-based, framework-based, and directory-based detection.
 import { readFile, readdir, stat } from 'node:fs/promises';
@@ -21,8 +22,8 @@ const IGNORE_PATTERNS = [
 ];
 const SOURCE_EXTENSIONS = '{ts,js,tsx,jsx,py,go,rs,java,kt,rb,cs,swift,dart}';
 const LANGUAGE_EXTENSION_MAP = {
-    ts: 'TypeScript',
-    tsx: 'TypeScript',
+    ts: technologyValue('technology-typescript-ed0504'),
+    tsx: technologyValue('technology-typescript-ed0504'),
     js: 'JavaScript',
     jsx: 'JavaScript',
     py: 'Python',

package/dist/engine/schema-generator.js

@@ -1,4 +1,4 @@
-// engine/schema-generator.ts — Validation Schema Generator (SPEC-365)
+import { technologyValue } from './technology-registry.js';
 // ---------------------------------------------------------------------------
 // Entity detection
 // ---------------------------------------------------------------------------
@@ -183,7 +183,9 @@ function valibotTypeFor(field) {
     return base;
 }
 function generateZodSchema(entities, format) {
-    const importLine = format === 'typescript' ? "import { z } from 'zod';" : "const { z } = require('zod');";
+    const importLine = format === technologyValue('technology-typescript-969545')
+        ? "import { z } from 'zod';"
+        : "const { z } = require('zod');";
     const schemas = entities
         .map((entity) => {
         const fields = entity.fields.map((f) => `  ${f.name}: ${zodTypeFor(f)},`).join('\n');
@@ -193,7 +195,9 @@ function generateZodSchema(entities, format) {
     return `${importLine}\n\n${schemas}\n`;
 }
 function generateYupSchema(entities, format) {
-    const importLine = format === 'typescript' ? "import * as yup from 'yup';" : "const yup = require('yup');";
+    const importLine = format === technologyValue('technology-typescript-969545')
+        ? "import * as yup from 'yup';"
+        : "const yup = require('yup');";
     const schemas = entities
         .map((entity) => {
         const fields = entity.fields.map((f) => `  ${f.name}: ${yupTypeFor(f)},`).join('\n');
@@ -203,7 +207,9 @@ function generateYupSchema(entities, format) {
     return `${importLine}\n\n${schemas}\n`;
 }
 function generateValibotSchema(entities, format) {
-    const importLine = format === 'typescript' ? "import * as v from 'valibot';" : "const v = require('valibot');";
+    const importLine = format === technologyValue('technology-typescript-969545')
+        ? "import * as v from 'valibot';"
+        : "const v = require('valibot');";
     const schemas = entities
         .map((entity) => {
         const fields = entity.fields.map((f) => `  ${f.name}: ${valibotTypeFor(f)},`).join('\n');
@@ -218,11 +224,11 @@ function generateValibotSchema(entities, format) {
 export function generateSchemas(specId, specText, library, outputFormat, outputPath) {
     const entities = detectEntities(specText);
     const schemas = [];
-    const libs = library === 'all' ? ['zod', 'yup', 'valibot'] : [library];
+    const libs = library === 'all' ? [technologyValue('technology-zod-4f63cf'), 'yup', 'valibot'] : [library];
     for (const lib of libs) {
         let code;
         switch (lib) {
-            case 'zod':
+            case technologyValue('technology-zod-4f63cf'):
                 code = generateZodSchema(entities, outputFormat);
                 break;
             case 'yup':
@@ -296,11 +302,12 @@ function generateTanstackClient(routes) {
                 `}`);
         }
         const bodyParam = hasBody ? 'body: unknown' : '';
+        const bodyOptions = hasBody
+            ? `\n    body: JSON.stringify(body),\n    headers: { 'Content-Type': 'application/json' },`
+            : '';
         return (`export function use${fnName.charAt(0).toUpperCase() + fnName.slice(1)}() {\n` +
             `  return useMutation({ mutationFn: (${bodyParam}) => fetch('${r.path}', {\n` +
-            `    method: '${r.method}',\n` +
-            `    body: JSON.stringify(body),\n` +
-            `    headers: { 'Content-Type': 'application/json' },\n` +
+            `    method: '${r.method}',${bodyOptions}\n` +
             `  }).then(r => r.json()) });\n` +
             `}`);
     })

package/dist/engine/security-analyzer/criteria-generator.js

@@ -1,5 +1,4 @@
-// engine/security-analyzer/criteria-generator.ts — OWASP criteria, auth criteria, STRIDE, compliance
-// SPEC-029
+import { technologyValue } from '../technology-registry.js';
 import { loadSecurityPatterns } from './config-loader.js';
 // === OWASP criteria generation ===
 export async function generateOwaspCriteria(profiles) {
@@ -54,7 +53,7 @@ export function detectComplianceFrameworks(description, projectDescription) {
         'pci',
         'cardholder',
         'merchant',
-        'stripe',
+        technologyValue('technology-stripe-2bed20'),
         'checkout',
         'billing',
     ];

package/dist/engine/self-healing/healer.js

@@ -1,4 +1,4 @@
-// engine/self-healing/healer.ts — SPEC-474: Self-Healing Loop
+import { technologyValue } from '../technology-registry.js';
 import { applyTypescriptFix } from './strategies/typescript-fix.js';
 import { applyLintFix } from './strategies/lint-fix.js';
 import { applyTestFix } from './strategies/test-fix.js';
@@ -10,7 +10,7 @@ const MAX_ATTEMPTS = 3;
 export function identifyFixStrategy(failureType) {
     switch (failureType) {
         case 'typecheck':
-            return 'typescript';
+            return technologyValue('technology-typescript-969545');
         case 'lint':
             return 'lint';
         case 'test':
@@ -18,7 +18,7 @@ export function identifyFixStrategy(failureType) {
         case 'coverage':
             return 'coverage';
         default:
-            return 'typescript';
+            return technologyValue('technology-typescript-969545');
     }
 }
 /**
@@ -26,7 +26,7 @@ export function identifyFixStrategy(failureType) {
  */
 function runStrategy(strategyName, projectPath, details) {
     switch (strategyName) {
-        case 'typescript':
+        case technologyValue('technology-typescript-969545'):
             return applyTypescriptFix(projectPath, details);
         case 'lint':
             return applyLintFix(projectPath, details);

package/dist/engine/session-safeguard/learnings-buffer.d.ts

@@ -2,8 +2,7 @@ import type { LearningsBuffer, LearningEntry } from '../../types/index.js';
 /** Read the learnings buffer for a project (best-effort, returns empty on miss). */
 export declare function readBuffer(projectPath: string): Promise<LearningsBuffer>;
 /**
- * Append an entry to the learnings buffer with exclusive-lock retry.
- * Uses 'wx' flag on a lock file with jitter-backoff (3 retries, 100ms each).
+ * Append an entry under the shared transactional lease authority.
  */
 export declare function appendToBuffer(projectPath: string, entry: LearningEntry): Promise<void>;
 /**

package/dist/engine/session-safeguard/learnings-buffer.js

@@ -1,11 +1,13 @@
 // engine/session-safeguard/learnings-buffer.ts — SPEC-585: Append/flush learnings buffer
-import { open, readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { readFile, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
+import { acquireLock, releaseLock } from '../safety/file-mutex.js';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { assertNoObsoleteFileLock } from '../safety/obsolete-lock-guard.js';
 const BUFFER_VERSION = 1;
-const MAX_RETRIES = 50;
-const JITTER_MS = 100;
+const LOCK_TIMEOUT_MS = 10_000;
 function bufferPath(projectPath) {
     const hash = hashProjectPath(projectPath);
     return join(projectDataDir(hash), 'learnings-buffer.json');
@@ -31,54 +33,27 @@ export async function readBuffer(projectPath) {
 async function writeBuffer(projectPath, buffer) {
     const path = bufferPath(projectPath);
     await mkdir(join(path, '..'), { recursive: true });
-    await writeFile(path, JSON.stringify(buffer, null, 2), 'utf-8');
+    await atomicWriteFile(path, JSON.stringify(buffer, null, 2));
+}
+async function withBufferLock(projectPath, operation) {
+    await assertNoObsoleteFileLock(`${bufferPath(projectPath)}.lock`, 'learnings buffer');
+    const handle = await acquireLock(bufferPath(projectPath), LOCK_TIMEOUT_MS);
+    try {
+        return await operation();
+    }
+    finally {
+        await releaseLock(handle);
+    }
 }
 /**
- * Append an entry to the learnings buffer with exclusive-lock retry.
- * Uses 'wx' flag on a lock file with jitter-backoff (3 retries, 100ms each).
+ * Append an entry under the shared transactional lease authority.
  */
 export async function appendToBuffer(projectPath, entry) {
-    const lockFile = `${bufferPath(projectPath)}.lock`;
-    await mkdir(join(lockFile, '..'), { recursive: true });
-    let lastError;
-    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-        try {
-            const fh = await open(lockFile, 'wx');
-            try {
-                const buffer = await readBuffer(projectPath);
-                buffer.entries.push(entry);
-                await writeBuffer(projectPath, buffer);
-            }
-            finally {
-                try {
-                    await fh.close();
-                }
-                catch {
-                    /* best-effort */
-                }
-                try {
-                    await unlink(lockFile);
-                }
-                catch {
-                    /* best-effort */
-                }
-            }
-            return;
-        }
-        catch (err) {
-            lastError = err;
-            const isExist = err instanceof Error && 'code' in err
-                ? err.code === 'EEXIST'
-                : false;
-            if (!isExist) {
-                break;
-            }
-            await new Promise((resolve) => setTimeout(resolve, JITTER_MS + Math.random() * JITTER_MS));
-        }
-    }
-    throw lastError instanceof Error
-        ? lastError
-        : new Error('Unable to acquire learnings buffer lock');
+    await withBufferLock(projectPath, async () => {
+        const buffer = await readBuffer(projectPath);
+        buffer.entries.push(entry);
+        await writeBuffer(projectPath, buffer);
+    });
 }
 /** Build the markdown bullet for an entry to append to MEMORY.md. */
 function entryToMarkdown(entry) {
@@ -92,23 +67,25 @@ function entryToMarkdown(entry) {
  * Returns the number of entries flushed.
  */
 export async function flushBuffer(projectPath) {
-    const buffer = await readBuffer(projectPath);
-    if (buffer.entries.length === 0) {
-        return 0;
-    }
-    const memoryPath = claudeMemoryPath(projectPath);
-    let existing = '';
-    try {
-        existing = await readFile(memoryPath, 'utf-8');
-    }
-    catch {
-        /* file may not exist */
-    }
-    const bullets = buffer.entries.map(entryToMarkdown).join('\n');
-    const section = `\n\n## Session Learnings (auto-flushed ${new Date().toISOString().slice(0, 10)})\n\n${bullets}\n`;
-    await mkdir(join(memoryPath, '..'), { recursive: true });
-    await writeFile(memoryPath, existing + section, 'utf-8');
-    await writeBuffer(projectPath, emptyBuffer());
-    return buffer.entries.length;
+    return withBufferLock(projectPath, async () => {
+        const buffer = await readBuffer(projectPath);
+        if (buffer.entries.length === 0) {
+            return 0;
+        }
+        const memoryPath = claudeMemoryPath(projectPath);
+        let existing = '';
+        try {
+            existing = await readFile(memoryPath, 'utf-8');
+        }
+        catch {
+            /* file may not exist */
+        }
+        const bullets = buffer.entries.map(entryToMarkdown).join('\n');
+        const section = `\n\n## Session Learnings (auto-flushed ${new Date().toISOString().slice(0, 10)})\n\n${bullets}\n`;
+        await mkdir(join(memoryPath, '..'), { recursive: true });
+        await atomicWriteFile(memoryPath, existing + section);
+        await writeBuffer(projectPath, emptyBuffer());
+        return buffer.entries.length;
+    });
 }
 //# sourceMappingURL=learnings-buffer.js.map

package/dist/engine/shared-agent-memory.js

@@ -1,40 +1,29 @@
 // engine/shared-agent-memory.ts — SPEC-689
-import { readFile, writeFile, mkdir, unlink, rename } from 'node:fs/promises';
+import { readFile, mkdir, rename } from 'node:fs/promises';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
+import { acquireLock, releaseLock } from '../engine/safety/file-mutex.js';
+import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
+import { assertNoObsoleteFileLock } from '../engine/safety/obsolete-lock-guard.js';
 const MAX_STORE_BYTES = 512 * 1024; // 512 KB
 const MAX_ENTRY_BYTES = 16 * 1024; // 16 KB
 const ENTRY_TTL_MS = 24 * 60 * 60 * 1000; // 24 h
 const EVICT_THRESHOLD = 0.8;
 const LOCK_TIMEOUT_MS = 5000;
-const LOCK_RETRY_INTERVAL_MS = 50;
 function storeDir(projectPath, specId) {
-    return join(projectPath, '.planu', 'team', specId);
+    return join(projectDataDir(hashProjectPath(projectPath)), 'team', specId);
 }
 function storePath(projectPath, specId) {
     return join(storeDir(projectPath, specId), 'shared-memory.json');
 }
-function lockPath(projectPath, specId) {
-    return join(storeDir(projectPath, specId), 'shared-memory.json.lock');
-}
-async function acquireLock(lockFile) {
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        try {
-            await writeFile(lockFile, process.pid.toString(), { flag: 'wx' });
-            return true;
-        }
-        catch {
-            await new Promise((r) => setTimeout(r, LOCK_RETRY_INTERVAL_MS));
-        }
-    }
-    return false;
-}
-async function releaseLock(lockFile) {
+async function withMemoryLock(projectPath, specId, operation) {
+    await assertNoObsoleteFileLock(`${storePath(projectPath, specId)}.lock`, `shared memory for ${specId}`);
+    const handle = await acquireLock(storePath(projectPath, specId), LOCK_TIMEOUT_MS);
     try {
-        await unlink(lockFile);
+        return await operation();
     }
-    catch {
-        // ignore — lock file may already be gone
+    finally {
+        await releaseLock(handle);
     }
 }
 async function readStore(projectPath, specId) {
@@ -55,7 +44,7 @@ async function readStore(projectPath, specId) {
 async function persistStore(projectPath, specId, store) {
     await mkdir(storeDir(projectPath, specId), { recursive: true });
     const updated = { ...store, updatedAt: new Date().toISOString() };
-    await writeFile(storePath(projectPath, specId), JSON.stringify(updated, null, 2), 'utf-8');
+    await atomicWriteFile(storePath(projectPath, specId), JSON.stringify(updated, null, 2));
 }
 function calcSizeBytes(entries) {
     let total = 0;
@@ -87,67 +76,70 @@ function evictLru(store) {
     return { ...store, entries, sizeBytes: calcSizeBytes(entries) };
 }
 export async function readSharedMemory(projectPath, specId, key) {
-    let store = await readStore(projectPath, specId);
-    store = pruneExpired(store);
-    const entry = store.entries[key];
-    if (entry === undefined) {
-        return undefined;
-    }
-    const updated = {
-        ...store,
-        entries: {
-            ...store.entries,
-            [key]: { ...entry, accessedAt: new Date().toISOString() },
-        },
-    };
-    await persistStore(projectPath, specId, updated);
-    return entry.value;
+    return withMemoryLock(projectPath, specId, async () => {
+        let store = await readStore(projectPath, specId);
+        store = pruneExpired(store);
+        const entry = store.entries[key];
+        if (entry === undefined) {
+            return undefined;
+        }
+        await persistStore(projectPath, specId, {
+            ...store,
+            entries: {
+                ...store.entries,
+                [key]: { ...entry, accessedAt: new Date().toISOString() },
+            },
+        });
+        return entry.value;
+    });
 }
 export async function writeSharedMemory(projectPath, specId, key, value, agentId) {
     const newEntrySize = Buffer.byteLength(JSON.stringify(value));
     if (newEntrySize > MAX_ENTRY_BYTES) {
         return { ok: false, key, error: 'value too large' };
     }
-    const lockFile = lockPath(projectPath, specId);
     await mkdir(storeDir(projectPath, specId), { recursive: true });
-    const acquired = await acquireLock(lockFile);
-    if (!acquired) {
-        return { ok: false, key, error: 'lock timeout' };
-    }
     try {
-        let store = await readStore(projectPath, specId);
-        store = pruneExpired(store);
-        if (store.sizeBytes + newEntrySize > MAX_STORE_BYTES * EVICT_THRESHOLD) {
-            store = evictLru(store);
-        }
-        if (store.sizeBytes + newEntrySize > MAX_STORE_BYTES) {
-            return { ok: false, key, error: 'memory cap reached' };
-        }
-        const now = new Date().toISOString();
-        const entry = {
-            key,
-            value,
-            writtenBy: agentId,
-            expiresAt: new Date(Date.now() + ENTRY_TTL_MS).toISOString(),
-            accessedAt: now,
-        };
-        const finalStore = {
-            ...store,
-            entries: { ...store.entries, [key]: entry },
-            sizeBytes: store.sizeBytes + newEntrySize,
-        };
-        await persistStore(projectPath, specId, finalStore);
-        return { ok: true, key };
+        return await withMemoryLock(projectPath, specId, async () => {
+            let store = await readStore(projectPath, specId);
+            store = pruneExpired(store);
+            if (store.sizeBytes + newEntrySize > MAX_STORE_BYTES * EVICT_THRESHOLD) {
+                store = evictLru(store);
+            }
+            if (store.sizeBytes + newEntrySize > MAX_STORE_BYTES) {
+                return { ok: false, key, error: 'memory cap reached' };
+            }
+            const now = new Date().toISOString();
+            const entry = {
+                key,
+                value,
+                writtenBy: agentId,
+                expiresAt: new Date(Date.now() + ENTRY_TTL_MS).toISOString(),
+                accessedAt: now,
+            };
+            const finalStore = {
+                ...store,
+                entries: { ...store.entries, [key]: entry },
+                sizeBytes: store.sizeBytes + newEntrySize,
+            };
+            await persistStore(projectPath, specId, finalStore);
+            return { ok: true, key };
+        });
     }
-    finally {
-        await releaseLock(lockFile);
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'LOCK_TIMEOUT') {
+            return { ok: false, key, error: 'lock timeout' };
+        }
+        throw error;
     }
 }
 export async function archiveSharedMemory(projectPath, specId) {
-    const src = storePath(projectPath, specId);
-    const archiveDir = join(storeDir(projectPath, specId), 'archive');
-    await mkdir(archiveDir, { recursive: true });
-    const dest = join(archiveDir, `shared-memory-${Date.now().toString()}.json`);
-    await rename(src, dest);
+    await withMemoryLock(projectPath, specId, async () => {
+        const src = storePath(projectPath, specId);
+        const archiveDir = join(storeDir(projectPath, specId), 'archive');
+        await mkdir(archiveDir, { recursive: true });
+        const dest = join(archiveDir, `shared-memory-${Date.now().toString()}.json`);
+        await rename(src, dest);
+    });
 }
 //# sourceMappingURL=shared-agent-memory.js.map

package/dist/engine/skill-adapter/command-rewriter.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // src/engine/skill-adapter/command-rewriter.ts — SPEC-682: Regex-based command rewrites
 // Pure functions — no I/O, no side effects.
 /** Rewrite package manager commands in content.
@@ -21,10 +22,10 @@ export function rewriteTestRunnerCommands(content, testCommand) {
         return content;
     }
     // Detect if this project uses vitest
-    const usesVitest = testCommand.includes('vitest');
+    const usesVitest = testCommand.includes(technologyValue('technology-vitest-a9127f'));
     if (usesVitest) {
         // Replace word-boundary 'jest' occurrences (not inside identifiers like jestConfig)
-        return content.replace(/\bjest\b/g, 'vitest');
+        return content.replace(/\bjest\b/g, technologyValue('technology-vitest-a9127f'));
     }
     return content;
 }

package/dist/engine/skill-adapter/index.js

@@ -5,6 +5,8 @@ import { join } from 'node:path';
 import { readSkillRegistry, writeSkillRegistryEntry, } from '../../storage/skill-registry-storage.js';
 import { PLACEHOLDER_MAP } from './placeholder-map.js';
 import { rewritePackageManagerCommands, rewriteTestRunnerCommands } from './command-rewriter.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
 export { PLACEHOLDER_MAP } from './placeholder-map.js';
 export { rewritePackageManagerCommands, rewriteTestRunnerCommands } from './command-rewriter.js';
 // ---------------------------------------------------------------------------
@@ -84,8 +86,6 @@ export function adaptSkillContent(rawContent, knowledge) {
 // ---------------------------------------------------------------------------
 // File I/O orchestration
 // ---------------------------------------------------------------------------
-/** Cache directory path relative to projectPath */
-const CACHE_REL = '.planu/skill-cache';
 /** Installation directory relative to projectPath */
 const INSTALL_REL = '.claude/skills';
 /**
@@ -101,7 +101,7 @@ export async function adaptAndInstallSkill(projectPath, skillName, knowledge) {
     const entry = registry.installed[skillName];
     const source = entry?.source ?? 'anthropic'; // default to 'anthropic' if not yet registered
     // Resolve raw cache path
-    const cachePath = join(projectPath, CACHE_REL, source, `${skillName}.md`);
+    const cachePath = join(resolveStorageLayout().cache, 'skills', hashProjectPath(projectPath), source, `${skillName}.md`);
     // Read raw content — throw if missing (caller should re-fetch via SPEC-681)
     let rawContent;
     try {

package/dist/engine/skill-adapter/placeholder-map.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 /**
  * Ordered list of placeholder definitions used during skill adaptation.
  * Each entry maps a template placeholder to a ProjectKnowledge field or a derive function.
@@ -26,7 +27,7 @@ export const PLACEHOLDER_MAP = [
     {
         placeholder: '{language}',
         knowledgePath: 'language',
-        fallback: 'typescript',
+        fallback: technologyValue('technology-typescript-969545'),
     },
     {
         placeholder: '{framework}',
@@ -36,7 +37,7 @@ export const PLACEHOLDER_MAP = [
     {
         placeholder: '{test_runner}',
         knowledgePath: null,
-        fallback: 'vitest',
+        fallback: technologyValue('technology-vitest-a9127f'),
         derive: (k) => {
             if (!k.testCommand) {
                 return null;