@myagentroam/node 0.9.119 → 0.9.121

package/dist/runner/codex-runner.js

@@ -24,13 +24,11 @@ export class CodexRunner extends AbstractRunner {
     fastEnabled = false;
     environmentFingerprint;
     environmentRuns = new Set();
-    profileCache = new Map();
-    profileCacheTimers = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileCacheVersion;
+    profileCacheTimer;
+    profileRefresh;
     profileClients = new Set();
-    profileKeyByEnvironment = new Map();
-    latestProfileCache;
-    selectedProfileKey;
     profileGeneration = 0;
     constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
         super();
@@ -43,40 +41,39 @@ export class CodexRunner extends AbstractRunner {
             claudeCodeAvailable: capabilities.claudeCode.available,
             openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
-        return { ...base, models: this.latestProfileCache?.profile.models ?? [] };
+        return { ...base, models: this.profileCache?.profile.models ?? [] };
     }
     cachedProfile(capabilities, environment = {}) {
         const base = this.profile(capabilities);
-        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
-        const cached = this.profileCache.get(key);
-        return cached === undefined ? { ...base, models: [] } : cached.profile;
+        return this.profileCache === undefined ||
+            this.profileCacheVersion !== capabilities.codex.version
+            ? { ...base, models: [] }
+            : this.profileCache.profile;
     }
     async refreshProfile(capabilities, workspace, environment = {}, waitForRefresh = false) {
         void workspace;
         const base = this.profile(capabilities);
         if (!capabilities.codex.available)
             return { ...base, models: [] };
-        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
-        this.profileKeyByEnvironment.set(codexSecretEnvironmentFingerprint(environment), key);
-        this.selectedProfileKey = key;
+        const version = capabilities.codex.version;
         const now = Date.now();
-        const cached = this.profileCache.get(key);
+        const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
         if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
-            return this.selectCachedProfile(key, cached);
+            return cached.profile;
         if (cached?.successful === true) {
             if (now >= cached.retryAt) {
-                const refresh = this.refreshCodexProfile(key, base, environment);
+                const refresh = this.refreshCodexProfile(version, base, environment);
                 if (waitForRefresh)
                     return refresh;
             }
-            return this.selectCachedProfile(key, cached);
+            return cached.profile;
         }
         if (cached !== undefined && now < cached.retryAt)
             return cached.profile;
-        return this.refreshCodexProfile(key, base, environment);
+        return this.refreshCodexProfile(version, base, environment);
     }
-    refreshCodexProfile(key, base, environment) {
-        const existing = this.profileRefreshes.get(key);
+    refreshCodexProfile(version, base, environment) {
+        const existing = this.profileRefresh;
         if (existing !== undefined)
             return existing;
         const generation = this.profileGeneration;
@@ -88,11 +85,8 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            if (generation === this.profileGeneration) {
-                this.cacheProfile(key, cache);
-                if (this.selectedProfileKey === key)
-                    this.latestProfileCache = cache;
-            }
+            if (generation === this.profileGeneration)
+                this.cacheProfile(version, cache);
             return cache.profile;
         })
             .catch((error) => {
@@ -101,12 +95,12 @@ export class CodexRunner extends AbstractRunner {
             });
             if (generation !== this.profileGeneration)
                 return { ...base, models: [] };
-            const cached = this.profileCache.get(key);
+            const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
             if (cached !== undefined) {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
                 return cached.profile;
             }
-            this.cacheProfile(key, {
+            this.cacheProfile(version, {
                 profile: { ...base, models: [] },
                 defaultConfiguration: emptyCodexConfiguration(),
                 fetchedAt: 0,
@@ -115,33 +109,24 @@ export class CodexRunner extends AbstractRunner {
             });
             return { ...base, models: [] };
         })
-            .finally(() => this.profileRefreshes.delete(key));
-        this.profileRefreshes.set(key, refresh);
+            .finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
+        });
+        this.profileRefresh = refresh;
         return refresh;
     }
-    selectCachedProfile(key, cached) {
-        if (cached.successful && this.selectedProfileKey === key)
-            this.latestProfileCache = cached;
-        return cached.profile;
-    }
-    cacheProfile(key, cache) {
-        const previousTimer = this.profileCacheTimers.get(key);
-        if (previousTimer !== undefined)
-            clearTimeout(previousTimer);
-        this.profileCache.set(key, cache);
-        const timer = setTimeout(() => {
-            this.profileCacheTimers.delete(key);
-            this.profileCache.delete(key);
-            for (const [environmentKey, profileKey] of this.profileKeyByEnvironment)
-                if (profileKey === key)
-                    this.profileKeyByEnvironment.delete(environmentKey);
-            if (this.selectedProfileKey === key) {
-                this.selectedProfileKey = undefined;
-                this.latestProfileCache = undefined;
-            }
+    cacheProfile(version, cache) {
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCache = cache;
+        this.profileCacheVersion = version;
+        this.profileCacheTimer = setTimeout(() => {
+            this.profileCacheTimer = undefined;
+            this.profileCache = undefined;
+            this.profileCacheVersion = undefined;
         }, CODEX_PROFILE_ENTRY_TTL_MS);
-        timer.unref();
-        this.profileCacheTimers.set(key, timer);
+        this.profileCacheTimer.unref();
     }
     async fetchCodexProfile(base, environment) {
         const client = this.profileClientFactory();
@@ -306,11 +291,8 @@ export class CodexRunner extends AbstractRunner {
             profile.models.some((model) => model.id === configuration.model && model.supportedEfforts.includes(configuration.effort)) &&
             profile.accessOptions.some((option) => option.id === configuration.access));
     }
-    profileCacheForEnvironment(environment) {
-        if (environment === undefined)
-            return this.latestProfileCache;
-        const key = this.profileKeyByEnvironment.get(codexSecretEnvironmentFingerprint(environment));
-        return key === undefined ? undefined : this.profileCache.get(key);
+    profileCacheForEnvironment(_environment) {
+        return this.profileCache;
     }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
@@ -483,13 +465,12 @@ export class CodexRunner extends AbstractRunner {
             this.client.clearEnvironment();
         this.environmentFingerprint = undefined;
         this.environmentRuns.clear();
-        for (const timer of this.profileCacheTimers.values())
-            clearTimeout(timer);
-        this.profileCacheTimers.clear();
-        this.profileCache.clear();
-        this.profileKeyByEnvironment.clear();
-        this.latestProfileCache = undefined;
-        this.selectedProfileKey = undefined;
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCacheTimer = undefined;
+        this.profileCache = undefined;
+        this.profileCacheVersion = undefined;
+        this.profileRefresh = undefined;
     }
     request(method, params) {
         return this.client.request(method, params);
@@ -537,19 +518,6 @@ export class CodexRunner extends AbstractRunner {
 function emptyCodexConfiguration() {
     return { runner: 'codex', model: '', effort: '', access: 'on-request' };
 }
-function codexEnvironmentFingerprint(environment, version) {
-    return createHash('sha256')
-        .update(JSON.stringify({
-        environment: Object.entries(environment).sort(([left], [right]) => left.localeCompare(right)),
-        version: version ?? null
-    }))
-        .digest('base64url');
-}
-function codexSecretEnvironmentFingerprint(environment) {
-    return createHash('sha256')
-        .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
-        .digest('base64url');
-}
 function codexModelPage(value) {
     if (!isPlainRecord(value) || !Array.isArray(value.data))
         throw new Error('CODEX_MODELS_INVALID');

package/dist/runner/mar-agent/managed-run-controller.js

@@ -244,6 +244,7 @@ export class MarAgentManagedRunController {
         let executionModels = [];
         try {
             const sessionKey = input.externalSessionId ?? input.sessionId;
+            // Reserve both identities while opening so a concurrent release can await the same runtime.
             const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
             if (acquisitionKeys.some((key) => this.#runtimeAcquisitions.get(key) !== undefined))
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');

package/dist/runner/opencode-runner.js

@@ -18,9 +18,9 @@ export class OpenCodeRunner extends AbstractRunner {
     discoveryScope = 'WORKSPACE_REQUIRED';
     contextLimits = new Map();
     contextLimitsExpiresAt = 0;
-    profileCache = new Map();
-    profileRetryAt = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileRetryAt = 0;
+    profileRefresh;
     profileGeneration = 0;
     execution = new Map();
     managedTurns = new Map();
@@ -41,7 +41,7 @@ export class OpenCodeRunner extends AbstractRunner {
     }
     cachedProfile(capabilities, environment = {}) {
         this.pruneProfileCaches(Date.now());
-        const cached = this.profileCache.get(this.environmentFingerprint(environment));
+        const cached = this.profileCache;
         return cached === undefined
             ? this.profile(capabilities)
             : { ...this.profile(capabilities), models: cached.models };
@@ -50,10 +50,9 @@ export class OpenCodeRunner extends AbstractRunner {
         if (capabilities.openCode?.available !== true) {
             return this.profile(capabilities);
         }
-        const cacheKey = this.environmentFingerprint(environment);
         const now = Date.now();
         this.pruneProfileCaches(now);
-        const cached = this.profileCache.get(cacheKey);
+        const cached = this.profileCache;
         if (cached !== undefined && cached.expiresAt > now) {
             nodeLog('runner.opencode.profile.cache-hit', {
                 models: cached.models.length,
@@ -63,24 +62,24 @@ export class OpenCodeRunner extends AbstractRunner {
             this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
-        if (now < (this.profileRetryAt.get(cacheKey) ?? 0))
+        if (now < this.profileRetryAt)
             return cached === undefined
                 ? this.profile(capabilities)
                 : { ...this.profile(capabilities), models: cached.models };
-        const current = this.profileRefreshes.get(cacheKey);
+        const current = this.profileRefresh;
         if (current !== undefined) {
             nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
         const generation = this.profileGeneration;
-        const refresh = this.fetchProfile(capabilities, environment, cacheKey, generation, cached).finally(() => {
-            if (this.profileRefreshes.get(cacheKey) === refresh)
-                this.profileRefreshes.delete(cacheKey);
+        const refresh = this.fetchProfile(capabilities, environment, generation, cached).finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
         });
-        this.profileRefreshes.set(cacheKey, refresh);
+        this.profileRefresh = refresh;
         return refresh;
     }
-    async fetchProfile(capabilities, environment, cacheKey, generation, stale) {
+    async fetchProfile(capabilities, environment, generation, stale) {
         const client = this.managedClient(environment, 'runner-profile');
         const startedAt = performance.now();
         try {
@@ -92,14 +91,13 @@ export class OpenCodeRunner extends AbstractRunner {
                 return this.profile(capabilities);
             this.contextLimits = contextLimits;
             this.contextLimitsExpiresAt = expiresAt;
-            this.profileCache.set(cacheKey, {
+            this.profileCache = {
                 expiresAt,
                 discardAt: Date.now() + PROFILE_STALE_TTL_MS,
-                environmentFingerprint: cacheKey,
                 models,
                 contextLimits
-            });
-            this.profileRetryAt.delete(cacheKey);
+            };
+            this.profileRetryAt = 0;
             nodeLog('runner.opencode.profile.providers.completed', {
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
@@ -109,7 +107,7 @@ export class OpenCodeRunner extends AbstractRunner {
         catch {
             if (generation !== this.profileGeneration)
                 return this.profile(capabilities);
-            this.profileRetryAt.set(cacheKey, Date.now() + PROFILE_FAILURE_RETRY_MS);
+            this.profileRetryAt = Date.now() + PROFILE_FAILURE_RETRY_MS;
             nodeLog('runner.opencode.profile.providers.failed', {
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -121,10 +119,6 @@ export class OpenCodeRunner extends AbstractRunner {
             ? this.profile(capabilities)
             : { ...this.profile(capabilities), models: stale.models };
     }
-    environmentFingerprint(environment) {
-        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
-        return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
-    }
     available(capabilities) {
         return capabilities.openCode?.available === true;
     }
@@ -160,21 +154,16 @@ export class OpenCodeRunner extends AbstractRunner {
     }
     cachedModels(environment) {
         this.pruneProfileCaches(Date.now());
-        const fingerprint = this.environmentFingerprint(environment);
-        return [...this.profileCache.values()]
-            .filter((entry) => entry.environmentFingerprint === fingerprint)
-            .flatMap((entry) => entry.models);
+        void environment;
+        return this.profileCache?.models ?? [];
     }
     pruneProfileCaches(now) {
-        for (const [key, entry] of this.profileCache) {
-            if (entry.discardAt > now)
-                continue;
-            this.profileCache.delete(key);
-            this.profileRetryAt.delete(key);
-        }
-        for (const [key, retryAt] of this.profileRetryAt)
-            if (retryAt <= now && !this.profileCache.has(key) && !this.profileRefreshes.has(key))
-                this.profileRetryAt.delete(key);
+        if (this.profileCache !== undefined && this.profileCache.discardAt <= now)
+            this.profileCache = undefined;
+        if (this.profileRetryAt <= now &&
+            this.profileCache === undefined &&
+            this.profileRefresh === undefined)
+            this.profileRetryAt = 0;
     }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
@@ -340,9 +329,9 @@ export class OpenCodeRunner extends AbstractRunner {
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
-        this.profileCache.clear();
-        this.profileRefreshes.clear();
-        this.profileRetryAt.clear();
+        this.profileCache = undefined;
+        this.profileRefresh = undefined;
+        this.profileRetryAt = 0;
         this.contextLimits = new Map();
         this.contextLimitsExpiresAt = 0;
         const stopping = [

package/dist/runner/runner-registry.js

@@ -41,6 +41,14 @@ export class RunnerRegistry {
             try {
                 return await runner.refreshProfile(capabilities, workspace, environment, waitForRefresh);
             }
+            catch (error) {
+                nodeLog('runner.profile.refresh.failed', {
+                    runner: runner.name,
+                    workspaceId: workspace?.id,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return runner.cachedProfile(capabilities, environment);
+            }
             finally {
                 const durationMs = Math.round(performance.now() - startedAt);
                 if (durationMs >= 100)

package/dist/service/conversation-template-node-service.js

@@ -515,8 +515,7 @@ export class ConversationTemplateNodeService {
             manifest.entries.length !== numberValue(row, 'file_count') ||
             manifest.entries.reduce((total, entry) => total + entry.size, 0) !==
                 numberValue(row, 'total_bytes') ||
-            snapshotContentHash(manifest.directories, manifest.entries, manifest.schemaVersion) !==
-                manifest.contentHash)
+            snapshotContentHash(manifest.directories, manifest.entries) !== manifest.contentHash)
             throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
         const expected = new Map(manifest.entries.map((entry) => [entry.relativePath, entry]));
         const expectedDirectories = new Set([...manifest.directories, 'inbox', 'output']);
@@ -734,17 +733,6 @@ async function listSnapshotEntries(root, expectedDirectories, actualDirectories,
     }
     return entries;
 }
-function legacyPublishedDirectories(entries) {
-    const directories = new Set(['inbox', 'output']);
-    for (const entry of entries) {
-        const parts = entry.relativePath.split('/');
-        for (let index = 1; index < parts.length; index += 1)
-            directories.add(parts.slice(0, index).join('/'));
-    }
-    directories.delete('inbox');
-    directories.delete('output');
-    return [...directories].sort((left, right) => left.localeCompare(right, 'en-US'));
-}
 function forcedExcluded(relativePath) {
     const parts = relativePath.split('/');
     if (parts.some((part) => {
@@ -814,19 +802,6 @@ function templateVersionManifest(input) {
         typeof input['mcpConfigHash'] !== 'string' ||
         typeof input['contentHash'] !== 'string')
         throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    if (input['schemaVersion'] === 1) {
-        if (!Array.isArray(input['files']))
-            throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-        const entries = input['files'].map((value) => manifestFile(value));
-        return {
-            schemaVersion: 1,
-            directories: legacyPublishedDirectories(entries),
-            entries,
-            contentHash: input['contentHash'],
-            mcpServers,
-            mcpConfigHash: input['mcpConfigHash']
-        };
-    }
     if (input['schemaVersion'] !== 2 ||
         typeof input['sourceWorkspacePath'] !== 'string' ||
         !Array.isArray(input['directories']) ||
@@ -913,15 +888,7 @@ function safeNonNegativeInteger(input) {
         throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
     return input;
 }
-function snapshotContentHash(directories, entries, schemaVersion = 2) {
-    if (schemaVersion === 1)
-        return hashText(entries
-            .map((entry) => {
-            if (entry.kind !== 'FILE')
-                throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-            return `${entry.relativePath}\0${entry.size}\0${entry.sha256}`;
-        })
-            .join('\n'));
+function snapshotContentHash(directories, entries) {
     return hashText([
         ...directories.map((directory) => `DIRECTORY\0${directory}`),
         ...entries.map((entry) => entry.kind === 'FILE'

package/dist/service/goal-mcp-server.js

@@ -9,6 +9,7 @@ export class GoalMcpServer {
     goals;
     changed;
     capabilities = new Map();
+    sockets = new Set();
     endpoint = process.platform === 'win32'
         ? `\\\\.\\pipe\\mar-goal-${process.pid}-${randomUUID()}`
         : join(tmpdir(), `mar-goal-${process.pid}-${randomUUID()}.sock`);
@@ -48,7 +49,10 @@ export class GoalMcpServer {
             return;
         const server = await this.listening;
         this.capabilities.clear();
-        await new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+        const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+        for (const socket of this.sockets)
+            socket.destroy();
+        await closed;
         if (process.platform !== 'win32')
             await unlink(this.endpoint).catch(() => undefined);
     }
@@ -65,6 +69,8 @@ export class GoalMcpServer {
                 this.capabilities.set(token, { ...capability, sessionId: nextId });
     }
     handle(socket) {
+        this.sockets.add(socket);
+        socket.once('close', () => this.sockets.delete(socket));
         let body = '';
         socket.setEncoding('utf8');
         socket.on('data', (chunk) => {

package/dist/service/hosted-conversation-node-service.js

@@ -1537,9 +1537,7 @@ export class HostedConversationNodeService {
     processExecutor(paths, version, temporaryDirectory = paths.temporaryRootDirectory, generatedImagesDirectory, generatedImagesLogicalPath) {
         return this.options.processExecutorFactory({
             workspaceDirectory: version.templateDirectory,
-            ...(version.sourceWorkspacePath === undefined
-                ? {}
-                : { sourceWorkspacePath: version.sourceWorkspacePath }),
+            sourceWorkspacePath: version.sourceWorkspacePath,
             inboxDirectory: paths.uploadsDirectory,
             outputDirectory: paths.outputDirectory,
             ...(generatedImagesDirectory === undefined || generatedImagesLogicalPath === undefined
@@ -1605,10 +1603,10 @@ export class HostedConversationNodeService {
         if (!record(persisted))
             throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
         const snapshot = publishedTemplateSnapshot(persisted);
-        const parsedDraft = publishedTemplateDraft(snapshot.schemaVersion, persisted.draft);
+        const parsedDraft = publishedTemplateDraft(persisted.draft);
         const draft = parsedDraft.draft;
         const mcpServers = publishedMcpServers(persisted.mcpServers);
-        const contentHash = publishedTemplateContentHash(snapshot.directories, snapshot.entries, snapshot.schemaVersion);
+        const contentHash = publishedTemplateContentHash(snapshot.directories, snapshot.entries);
         const totalBytes = snapshot.entries.reduce((total, entry) => total + entry.size, 0);
         if (persisted.mcpConfigHash !== row.mcp_config_hash ||
             createHash('sha256').update(JSON.stringify(mcpServers)).digest('hex') !==
@@ -1629,9 +1627,7 @@ export class HostedConversationNodeService {
             templateId,
             storageKey: row.storage_key,
             templateDirectory: contentDirectory,
-            ...(snapshot.sourceWorkspacePath === undefined
-                ? {}
-                : { sourceWorkspacePath: snapshot.sourceWorkspacePath }),
+            sourceWorkspacePath: snapshot.sourceWorkspacePath,
             draft,
             modelPolicy: parsedDraft.modelPolicy,
             mcpServers
@@ -1679,63 +1675,36 @@ function runtimeModels(value) {
 }
 function allowedModels(version, models) {
     const allowed = new Set(version.modelPolicy.allowedIds);
-    return models.filter((model) => model.enabled &&
-        allowed.has(version.modelPolicy.identity === 'UPSTREAM_MODEL_ID' ? model.modelId : model.id));
+    return models.filter((model) => model.enabled && allowed.has(model.modelId));
 }
 function selectModel(version, models, requestedModelId) {
     const available = allowedModels(version, models);
     const requested = available.find((candidate) => candidate.id === requestedModelId);
     if (requested !== undefined)
         return requested;
-    const defaultModel = available.find((candidate) => (version.modelPolicy.identity === 'UPSTREAM_MODEL_ID' ? candidate.modelId : candidate.id) ===
-        version.modelPolicy.defaultId);
+    const defaultModel = available.find((candidate) => candidate.modelId === version.modelPolicy.defaultId);
     if (defaultModel !== undefined)
         return defaultModel;
     const model = version.modelPolicy.allowedIds
-        .map((allowedId) => available.find((candidate) => (version.modelPolicy.identity === 'UPSTREAM_MODEL_ID'
-        ? candidate.modelId
-        : candidate.id) === allowedId))
+        .map((allowedId) => available.find((candidate) => candidate.modelId === allowedId))
         .find((candidate) => candidate !== undefined);
     if (model === undefined)
         throw new Error('HOSTED_CONVERSATION_MODEL_NOT_AVAILABLE');
     return model;
 }
-function publishedTemplateDraft(schemaVersion, value) {
+function publishedTemplateDraft(value) {
     const current = conversationTemplateDraftSchema.safeParse(value);
     if (current.success) {
         const { allowedModels, defaultModelId, ...draft } = current.data;
         return {
             draft,
             modelPolicy: {
-                identity: 'UPSTREAM_MODEL_ID',
                 allowedIds: allowedModels.map((model) => model.modelId),
                 defaultId: defaultModelId
             }
         };
     }
-    if (schemaVersion !== 1 ||
-        !record(value) ||
-        'allowedModels' in value ||
-        !Array.isArray(value.allowedModelIds))
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    const allowedModelIds = value.allowedModelIds;
-    const legacy = { ...value };
-    delete legacy.allowedModelIds;
-    const normalized = conversationTemplateDraftSchema.safeParse({
-        ...legacy,
-        allowedModels: allowedModelIds.map((modelId) => ({ modelId, name: modelId }))
-    });
-    if (!normalized.success)
-        throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-    const { allowedModels, defaultModelId, ...draft } = normalized.data;
-    return {
-        draft,
-        modelPolicy: {
-            identity: 'CONFIGURATION_ID',
-            allowedIds: allowedModels.map((model) => model.modelId),
-            defaultId: defaultModelId
-        }
-    };
+    throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
 }
 function networkModels(models, networkMode) {
     if (networkMode !== 'NONE')
@@ -1773,14 +1742,6 @@ function publishedMcpServers(value) {
     });
 }
 function publishedTemplateSnapshot(manifest) {
-    if (manifest.schemaVersion === 1) {
-        const entries = publishedTemplateFiles(manifest.files);
-        return {
-            schemaVersion: 1,
-            directories: legacyPublishedTemplateDirectories(entries),
-            entries
-        };
-    }
     if (manifest.schemaVersion !== 2 ||
         typeof manifest.sourceWorkspacePath !== 'string' ||
         !Array.isArray(manifest.directories) ||
@@ -1876,30 +1837,14 @@ function safePublishedTemplateSize(value) {
         throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
     return value;
 }
-function legacyPublishedTemplateDirectories(entries) {
-    const directories = new Set();
-    for (const entry of entries) {
-        const parts = entry.relativePath.split('/');
-        for (let index = 1; index < parts.length; index += 1)
-            directories.add(parts.slice(0, index).join('/'));
-    }
-    return [...directories].sort((left, right) => left.localeCompare(right, 'en-US'));
-}
-function publishedTemplateContentHash(directories, entries, schemaVersion) {
-    const content = schemaVersion === 1
-        ? entries
-            .map((entry) => {
-            if (entry.kind !== 'FILE')
-                throw new Error('CONVERSATION_TEMPLATE_VERSION_CORRUPTED');
-            return `${entry.relativePath}\0${entry.size}\0${entry.sha256}`;
-        })
-            .join('\n')
-        : [
-            ...directories.map((directory) => `DIRECTORY\0${directory}`),
-            ...entries.map((entry) => entry.kind === 'FILE'
-                ? `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.executable ? 1 : 0}\0${entry.sha256}`
-                : `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.linkTarget}\0${entry.targetKind}\0${entry.resolvedTarget}`)
-        ].join('\n');
+/** Current manifests hash directory and entry identities; changing the format requires a new version. */
+function publishedTemplateContentHash(directories, entries) {
+    const content = [
+        ...directories.map((directory) => `DIRECTORY\0${directory}`),
+        ...entries.map((entry) => entry.kind === 'FILE'
+            ? `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.executable ? 1 : 0}\0${entry.sha256}`
+            : `${entry.kind}\0${entry.relativePath}\0${entry.size}\0${entry.linkTarget}\0${entry.targetKind}\0${entry.resolvedTarget}`)
+    ].join('\n');
     return createHash('sha256').update(content).digest('hex');
 }
 function validatePublishedSourceWorkspacePath(path) {

package/dist/service/workspace-change-service.js

@@ -32,6 +32,7 @@ export class WorkspaceChangeService {
         const existing = this.state.changesReads.get(workspace.id);
         if (existing !== undefined)
             return existing;
+        // Invalidation may arrive during this shared read; its old result must not repopulate the cache.
         const version = this.state.changesVersions.get(workspace.id) ?? 0;
         const request = this.state.changesLimiter.run(async () => {
             const startedAt = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.119",
+  "version": "0.9.121",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "0.9.119",
-    "@myagentroam/agent": "0.9.119",
-    "@myagentroam/code-navigation": "0.9.119"
+    "@myagentroam/agent": "0.9.121",
+    "@myagentroam/code-navigation": "0.9.121",
+    "@myagentroam/protocol": "0.9.121"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"