@planu/cli 4.13.0 → 5.0.0

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/scope-boundaries/contradiction-checker.js

@@ -43,6 +43,58 @@ function keywords(phrase) {
         .split(' ')
         .filter((w) => w.length > 3 && !STOP_WORDS.has(w));
 }
+/** Return true only for explicit language that preserves an existing boundary. */
+function preservesBoundary(text) {
+    const normalized = normalize(text);
+    return [
+        /\bremains? unchanged\b/,
+        /\bkeeps?\b.{0,80}\bunchanged\b/,
+        /\bpreserves?\b.{0,80}\b(?:behavior|contract|boundary|semantics|state)\b/,
+        /\bwithout (?:any )?(?:changing|modifying|altering|adding|introducing)\b/,
+        /\b(?:does|do|must|will|should) not (?:change|modify|alter|add|introduce|implement|enable)\b/,
+        /\bno changes? to\b/,
+    ].some((pattern) => pattern.test(normalized));
+}
+function splitClauses(text) {
+    return text
+        .split(/\b(?:but|while|although|however)\b|[,;.]/i)
+        .map((clause) => clause.trim())
+        .filter(Boolean);
+}
+function hasAffirmativeDrift(text, outOfScopeItem) {
+    const action = /\b(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?)\b/g;
+    const actionSegments = text.split(/\band\b/i).map(normalize);
+    for (const [index, segment] of actionSegments.entries()) {
+        const inheritsRelevantSubject = index > 0 &&
+            /^(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?)\b/.test(segment) &&
+            clauseMatchesScope(actionSegments[index - 1] ?? '', outOfScopeItem);
+        for (const match of segment.matchAll(action)) {
+            const before = segment.slice(Math.max(0, match.index - 24), match.index);
+            const after = segment.slice(match.index + match[0].length);
+            if (/\b(?:not|without|no)\s*$/.test(before)) {
+                continue;
+            }
+            if (/^\s+remains? unchanged\b/.test(after)) {
+                continue;
+            }
+            if (inheritsRelevantSubject || clauseMatchesScope(segment, outOfScopeItem)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function clauseMatchesScope(clause, outOfScopeItem) {
+    const normalizedClause = normalize(clause);
+    const normalizedScope = normalize(outOfScopeItem);
+    if (normalizedClause.includes(normalizedScope) || normalizedScope.includes(normalizedClause)) {
+        return true;
+    }
+    const scopeKeywords = keywords(outOfScopeItem);
+    const matchCount = scopeKeywords.filter((keyword) => normalizedClause.includes(keyword)).length;
+    const threshold = scopeKeywords.length <= 2 ? scopeKeywords.length : 2;
+    return scopeKeywords.length > 0 && matchCount >= threshold;
+}
 /**
  * Determine whether a criterion text contradicts an out-of-scope item.
  * Uses substring match first, then keyword overlap as fuzzy fallback.
@@ -50,6 +102,13 @@ function keywords(phrase) {
 function contradicts(criterionText, outOfScopeItem) {
     const normCriterion = normalize(criterionText);
     const normScope = normalize(outOfScopeItem);
+    const relevantClauses = splitClauses(criterionText).filter((clause) => clauseMatchesScope(clause, outOfScopeItem));
+    const hasConditionalException = /\b(?:unless|except)\b/i.test(criterionText);
+    if (!hasConditionalException &&
+        relevantClauses.length > 0 &&
+        relevantClauses.every((clause) => preservesBoundary(clause) && !hasAffirmativeDrift(clause, outOfScopeItem))) {
+        return false;
+    }
     // 1. Direct substring match
     if (normCriterion.includes(normScope)) {
         return true;
@@ -74,9 +133,12 @@ function contradicts(criterionText, outOfScopeItem) {
  */
 export function checkContradictions(outOfScope, criteria) {
     const contradictions = [];
+    const seenPairs = new Set();
     for (const criterion of criteria) {
         for (const scopeItem of outOfScope) {
-            if (contradicts(criterion, scopeItem)) {
+            const pairKey = `${normalize(criterion)}\u0000${normalize(scopeItem)}`;
+            if (!seenPairs.has(pairKey) && contradicts(criterion, scopeItem)) {
+                seenPairs.add(pairKey);
                 contradictions.push({ criterion, contradicts: scopeItem });
             }
         }

package/dist/engine/scope-boundaries/scope-validator.js

@@ -24,10 +24,44 @@ const GENERIC_SCOPE_TOKENS = new Set([
     'tool',
     'tools',
 ]);
+const GENERIC_SEMANTIC_TOKENS = new Set([
+    'change',
+    'validation',
+    'evidence',
+    'format',
+    'semantic',
+    'schema',
+    'receipt',
+]);
+function inflectionCandidates(token) {
+    const candidates = [token];
+    if (token.endsWith('s')) {
+        candidates.push(token.slice(0, -1));
+    }
+    for (const suffix of ['ed', 'ing']) {
+        if (token.endsWith(suffix)) {
+            const stem = token.slice(0, -suffix.length);
+            candidates.push(stem, `${stem}e`);
+        }
+    }
+    return [...new Set(candidates.filter((candidate) => candidate.length >= 4))];
+}
+function semanticToken(token) {
+    const candidates = inflectionCandidates(token);
+    const generic = candidates.find((candidate) => GENERIC_SEMANTIC_TOKENS.has(candidate));
+    if (generic) {
+        return generic;
+    }
+    const singular = token.endsWith('s') ? token.slice(0, -1) : token;
+    return singular.length >= 4 ? singular : token;
+}
 function keywords(phrase) {
-    return normalize(phrase)
-        .split(' ')
-        .filter((w) => w.length > 2 && !STOP_WORDS.has(w) && !GENERIC_SCOPE_TOKENS.has(w));
+    return [
+        ...new Set(normalize(phrase)
+            .split(' ')
+            .filter((word) => word.length > 2 && !STOP_WORDS.has(word) && !GENERIC_SCOPE_TOKENS.has(word))
+            .map(semanticToken)),
+    ];
 }
 /**
  * Determine whether a file path matches an out-of-scope item.
@@ -39,9 +73,12 @@ function fileMatchesScopeItem(filePath, scopeItem) {
     if (scopeKws.length === 0) {
         return false;
     }
-    const matchCount = scopeKws.filter((kw) => normPath.includes(kw)).length;
-    // Require at least 1 keyword match for a warning
-    return matchCount >= 1;
+    const pathKeywords = new Set(keywords(normPath));
+    const specific = scopeKws.filter((token) => !GENERIC_SEMANTIC_TOKENS.has(token));
+    const matched = scopeKws.filter((token) => pathKeywords.has(token));
+    return specific.length > 0
+        ? specific.some((token) => pathKeywords.has(token))
+        : new Set(matched).size >= 2;
 }
 /**
  * Validate implementation file paths against the spec's outOfScope declarations.
@@ -52,8 +89,9 @@ export function validateScopeCompliance(outOfScope, filePaths) {
     for (const filePath of filePaths) {
         for (const scopeItem of outOfScope) {
             if (fileMatchesScopeItem(filePath, scopeItem)) {
+                const pathKeywords = new Set(keywords(filePath));
                 const matchedKws = keywords(scopeItem)
-                    .filter((kw) => normalize(filePath).includes(kw))
+                    .filter((keyword) => pathKeywords.has(keyword))
                     .join(', ');
                 warnings.push({
                     filePath,

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/checkpoint-writer.js

@@ -74,15 +74,6 @@ export async function writeCheckpoint(projectPath, snapshot) {
     const updated = replaceLatestCheckpoint(existing, newBlock);
     await mkdir(planuDir, { recursive: true });
     await writeFile(filePath, updated, 'utf8');
-    void (async () => {
-        try {
-            const { planuAutoCommit } = await import('../git/planu-autocommit.js');
-            await planuAutoCommit({ projectPath, reason: 'session-checkpoint' });
-        }
-        catch {
-            /* best-effort — never blocks checkpoint writer */
-        }
-    })();
 }
 /**
  * Fire-and-forget helper: records the tool call, then writes a checkpoint if

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;
 }