@planu/cli 5.1.1 → 5.2.0

package/dist/engine/vector-store/tfidf.js

@@ -1,6 +1,8 @@
 // engine/vector-store/tfidf.ts — TF-IDF embedding engine.
 // SPEC-075 AC-01: Tokenize, compute TF-IDF, generate dense vectors.
 import { normalizeVector } from './similarity.js';
+/** Bumped when the exported state shape changes; persisted stores rebuild on mismatch. */
+export const TFIDF_SCHEMA_VERSION = 1;
 const DEFAULT_STOP_WORDS = new Set([
     // English
     'the',
@@ -238,6 +240,7 @@ export class TFIDFEngine {
     /** Export state for serialization. */
     exportState() {
         return {
+            schemaVersion: TFIDF_SCHEMA_VERSION,
             docFreq: [...this.docFreq.entries()],
             docCount: this.docCount,
         };
@@ -251,5 +254,28 @@ export class TFIDFEngine {
         this.docCount = state.docCount;
         this.vocabDirty = true;
     }
+    /**
+     * Remove a document's contribution to the corpus (SPEC-1345: incremental
+     * updates). `tokens` must be the unique token set the document contributed
+     * when it was added via `addDocument` — callers persisting the index keep
+     * this alongside the content hash so a changed document can be decremented
+     * before its new version is added back in.
+     */
+    removeDocument(tokens) {
+        for (const term of new Set(tokens)) {
+            const freq = this.docFreq.get(term);
+            if (freq === undefined) {
+                continue;
+            }
+            if (freq <= 1) {
+                this.docFreq.delete(term);
+            }
+            else {
+                this.docFreq.set(term, freq - 1);
+            }
+        }
+        this.docCount = Math.max(0, this.docCount - 1);
+        this.vocabDirty = true;
+    }
 }
 //# sourceMappingURL=tfidf.js.map

package/dist/engine/worker-config-loader.d.ts

@@ -36,7 +36,7 @@ export declare class WorkerConfigLoader {
      *
      * Slug-to-env: 'test-gaps' → 'TEST_GAPS'
      * Full pattern: PLANU_WORKER_{WORKER_ENV}_{SETTING}
-     * Known settings: ENABLED (bool), COOLDOWNMS (number), PRIORITY (number), TIER (string)
+     * Known settings: ENABLED (bool), COOLDOWNMS (number), PRIORITY (number)
      */
     parseEnvOverride(workerName: string): WorkerOverride;
     /**

package/dist/engine/worker-config-loader.js

@@ -103,9 +103,6 @@ export class WorkerConfigLoader {
         if (typeof raw.priority === 'number') {
             override.priority = raw.priority;
         }
-        if (raw.tier === 'free' || raw.tier === 'pro') {
-            override.tier = raw.tier;
-        }
         return override;
     }
     /**
@@ -113,7 +110,7 @@ export class WorkerConfigLoader {
      *
      * Slug-to-env: 'test-gaps' → 'TEST_GAPS'
      * Full pattern: PLANU_WORKER_{WORKER_ENV}_{SETTING}
-     * Known settings: ENABLED (bool), COOLDOWNMS (number), PRIORITY (number), TIER (string)
+     * Known settings: ENABLED (bool), COOLDOWNMS (number), PRIORITY (number)
      */
     parseEnvOverride(workerName) {
         const envName = workerName.toUpperCase().replace(/-/g, '_');
@@ -137,10 +134,6 @@ export class WorkerConfigLoader {
                 override.priority = parsed;
             }
         }
-        const tierRaw = process.env[`${prefix}TIER`];
-        if (tierRaw === 'free' || tierRaw === 'pro') {
-            override.tier = tierRaw;
-        }
         return override;
     }
     /**
@@ -158,9 +151,6 @@ export class WorkerConfigLoader {
         if (override.priority !== undefined) {
             result.priority = override.priority;
         }
-        if (override.tier !== undefined) {
-            result.tier = override.tier;
-        }
         return result;
     }
 }

package/dist/engine/workers/schema.d.ts

@@ -26,10 +26,6 @@ export declare const WorkerDefinitionSchema: z.ZodObject<{
     priority: z.ZodNumber;
     cooldownMs: z.ZodNumber;
     enabled: z.ZodBoolean;
-    tier: z.ZodEnum<{
-        free: "free";
-        pro: "pro";
-    }>;
 }, z.core.$strip>;
 export declare const WorkerRegistrySchema: z.ZodObject<{
     workers: z.ZodArray<z.ZodObject<{
@@ -49,10 +45,6 @@ export declare const WorkerRegistrySchema: z.ZodObject<{
         priority: z.ZodNumber;
         cooldownMs: z.ZodNumber;
         enabled: z.ZodBoolean;
-        tier: z.ZodEnum<{
-            free: "free";
-            pro: "pro";
-        }>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/engine/workers/schema.js

@@ -33,7 +33,6 @@ export const WorkerDefinitionSchema = z.object({
     priority: z.number().int().min(1).max(10).describe('Priority 1-10, higher = more important'),
     cooldownMs: z.number().int().min(0).describe('Minimum milliseconds between executions'),
     enabled: z.boolean().describe('Whether the worker is active'),
-    tier: z.enum(['free', 'pro']).describe('License tier: free | pro'),
 });
 export const WorkerRegistrySchema = z.object({
     workers: z.array(WorkerDefinitionSchema).max(1000).describe('List of worker definitions'),

package/dist/i18n/index.d.ts

@@ -1,4 +1,22 @@
 import type { SupportedLocale } from '../types/index.js';
+/**
+ * SPEC-1347: Resolve the locale from environment variables only — no I/O.
+ * Priority: PLANU_LOCALE env var, then the LANG/LC_ALL prefix, then 'en'.
+ */
+export declare function resolveLocaleFromEnv(env?: NodeJS.ProcessEnv): SupportedLocale;
+/**
+ * SPEC-1347: Resolve the locale to use at startup. Priority order:
+ * (1) persisted global config value, (2) PLANU_LOCALE env var,
+ * (3) LANG/LC_ALL env prefix mapped to a supported locale, (4) 'en' fallback.
+ * Never throws — unreadable/missing config falls through to env detection.
+ */
+export declare function resolveInitialLocale(env?: NodeJS.ProcessEnv): SupportedLocale;
+/**
+ * SPEC-1347: Recompute and apply the initial locale. Called once at module load to replace
+ * the previously hardcoded 'en' default; also exported so tests (and any future explicit
+ * re-init after a config change) can force recomputation deterministically.
+ */
+export declare function initLocale(env?: NodeJS.ProcessEnv): SupportedLocale;
 /**
  * Get the currently active locale.
  */

package/dist/i18n/index.js

@@ -4,11 +4,50 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { readPersistedGlobalConfigSync } from '../storage/global-store.js';
 // ---------------------------------------------------------------------------
 // Internal state
 // ---------------------------------------------------------------------------
 const SUPPORTED_LOCALES = ['en', 'es', 'pt'];
-let currentLocale = 'en';
+/**
+ * SPEC-1347: Resolve the locale from environment variables only — no I/O.
+ * Priority: PLANU_LOCALE env var, then the LANG/LC_ALL prefix, then 'en'.
+ */
+export function resolveLocaleFromEnv(env = process.env) {
+    const explicit = env.PLANU_LOCALE;
+    if (explicit && isSupportedLocale(explicit)) {
+        return explicit;
+    }
+    const langRaw = env.LANG ?? env.LC_ALL;
+    const prefix = langRaw?.slice(0, 2).toLowerCase();
+    if (prefix && isSupportedLocale(prefix)) {
+        return prefix;
+    }
+    return 'en';
+}
+/**
+ * SPEC-1347: Resolve the locale to use at startup. Priority order:
+ * (1) persisted global config value, (2) PLANU_LOCALE env var,
+ * (3) LANG/LC_ALL env prefix mapped to a supported locale, (4) 'en' fallback.
+ * Never throws — unreadable/missing config falls through to env detection.
+ */
+export function resolveInitialLocale(env = process.env) {
+    const persisted = readPersistedGlobalConfigSync();
+    if (persisted && isSupportedLocale(persisted.defaultLocale)) {
+        return persisted.defaultLocale;
+    }
+    return resolveLocaleFromEnv(env);
+}
+/**
+ * SPEC-1347: Recompute and apply the initial locale. Called once at module load to replace
+ * the previously hardcoded 'en' default; also exported so tests (and any future explicit
+ * re-init after a config change) can force recomputation deterministically.
+ */
+export function initLocale(env = process.env) {
+    currentLocale = resolveInitialLocale(env);
+    return currentLocale;
+}
+let currentLocale = resolveInitialLocale();
 /** Locale -> flattened key->value map */
 const messageCache = new Map();
 // ---------------------------------------------------------------------------

package/dist/storage/global-store.d.ts

@@ -15,6 +15,15 @@ export declare function updateGlobalConfig(updates: Partial<GlobalConfig>): Prom
  * Set the default locale globally.
  */
 export declare function setDefaultLocale(locale: SupportedLocale): Promise<GlobalConfig>;
+/**
+ * SPEC-1347: Synchronous, best-effort read of the persisted global config.
+ *
+ * i18n needs a locale value before any async I/O can complete (module init time), so this
+ * mirrors `getGlobalConfig()` but reads the file synchronously and returns `null` — instead
+ * of defaults — when no config has ever been persisted. That distinction lets callers tell
+ * "never configured" (fall back to env detection) apart from "explicitly persisted".
+ */
+export declare function readPersistedGlobalConfigSync(): GlobalConfig | null;
 /**
  * Set the default experience level globally.
  */

package/dist/storage/global-store.js

@@ -1,6 +1,8 @@
 import { readJson, writeJson, globalDataDir } from './base-store.js';
 import { withFileLock } from './file-mutex.js';
 import { applyLearnedLimit, markVerified } from '../engine/registry-extender.js';
+import { readFileSync } from 'node:fs';
+import { reportClassifiedDegradation } from '../errors/classified-degradation.js';
 // --- file paths ---
 function configFile() {
     return `${globalDataDir()}/config.json`;
@@ -45,6 +47,27 @@ export async function updateGlobalConfig(updates) {
 export async function setDefaultLocale(locale) {
     return updateGlobalConfig({ defaultLocale: locale });
 }
+/**
+ * SPEC-1347: Synchronous, best-effort read of the persisted global config.
+ *
+ * i18n needs a locale value before any async I/O can complete (module init time), so this
+ * mirrors `getGlobalConfig()` but reads the file synchronously and returns `null` — instead
+ * of defaults — when no config has ever been persisted. That distinction lets callers tell
+ * "never configured" (fall back to env detection) apart from "explicitly persisted".
+ */
+export function readPersistedGlobalConfigSync() {
+    try {
+        const raw = readFileSync(configFile(), 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        reportClassifiedDegradation('GLOBAL_CONFIG_SYNC_READ_FAILURE', error);
+        return null;
+    }
+}
 /**
  * Set the default experience level globally.
  */

package/dist/storage/semantic-index-store.d.ts

@@ -0,0 +1,23 @@
+import { TFIDFEngine } from '../engine/vector-store/tfidf.js';
+import type { SemanticIndexDoc } from '../types/index.js';
+/**
+ * Persists a TF-IDF index for one logical corpus (e.g. all specs in a search
+ * scope, or a pattern type) and reconciles it incrementally against the
+ * current documents each time it is loaded.
+ */
+export declare class SemanticIndexStore {
+    private readonly filePath;
+    constructor(projectId: string, indexKey: string);
+    /**
+     * Load the persisted index and reconcile it with `docs`.
+     * - Unchanged documents are never re-embedded (`addDocument` is not called for them).
+     * - Changed or new documents are individually re-embedded and the index is re-persisted.
+     * - A missing, corrupted, schema-mismatched, or doc-removed index triggers a
+     *   transparent full rebuild so search always returns results.
+     */
+    loadOrBuild(docs: SemanticIndexDoc[]): Promise<TFIDFEngine>;
+    /** Full rebuild: fresh engine, `addDocument` for every doc, persist a new snapshot. */
+    private rebuildFull;
+    private persist;
+}
+//# sourceMappingURL=semantic-index-store.d.ts.map

package/dist/storage/semantic-index-store.js

@@ -0,0 +1,105 @@
+// storage/semantic-index-store.ts — Persisted TF-IDF index with incremental updates (SPEC-1345).
+// Avoids full corpus rebuilds on every semantic_search / learn call: persists the TF-IDF
+// engine state plus a per-document content-hash manifest, and only re-embeds documents
+// whose content changed since the last snapshot. A missing, corrupted, schema-mismatched,
+// or doc-removed index self-heals via a transparent full rebuild — never errors out.
+import { createHash } from 'node:crypto';
+import { readJson, writeJson, projectDataDir } from './base-store.js';
+import { withFileLock } from './file-mutex.js';
+import { TFIDFEngine, TFIDF_SCHEMA_VERSION, tokenize } from '../engine/vector-store/tfidf.js';
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function uniqueTokens(content) {
+    return [...new Set(tokenize(content))];
+}
+function isValidPersistedIndex(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    return (v.schemaVersion === TFIDF_SCHEMA_VERSION &&
+        typeof v.docHashes === 'object' &&
+        v.docHashes !== null &&
+        typeof v.docTokens === 'object' &&
+        v.docTokens !== null &&
+        typeof v.tfidfState === 'object' &&
+        v.tfidfState !== null);
+}
+/**
+ * Persists a TF-IDF index for one logical corpus (e.g. all specs in a search
+ * scope, or a pattern type) and reconciles it incrementally against the
+ * current documents each time it is loaded.
+ */
+export class SemanticIndexStore {
+    filePath;
+    constructor(projectId, indexKey) {
+        this.filePath = `${projectDataDir(projectId)}/semantic-index-${indexKey}.json`;
+    }
+    /**
+     * Load the persisted index and reconcile it with `docs`.
+     * - Unchanged documents are never re-embedded (`addDocument` is not called for them).
+     * - Changed or new documents are individually re-embedded and the index is re-persisted.
+     * - A missing, corrupted, schema-mismatched, or doc-removed index triggers a
+     *   transparent full rebuild so search always returns results.
+     */
+    async loadOrBuild(docs) {
+        const persisted = await readJson(this.filePath, null);
+        if (!isValidPersistedIndex(persisted)) {
+            return this.rebuildFull(docs);
+        }
+        const currentIds = new Set(docs.map((d) => d.id));
+        const hadRemoval = Object.keys(persisted.docHashes).some((id) => !currentIds.has(id));
+        if (hadRemoval) {
+            return this.rebuildFull(docs);
+        }
+        const engine = new TFIDFEngine();
+        engine.importState(persisted.tfidfState);
+        const docHashes = { ...persisted.docHashes };
+        const docTokens = { ...persisted.docTokens };
+        let changed = false;
+        for (const doc of docs) {
+            const hash = hashContent(doc.content);
+            if (docHashes[doc.id] === hash) {
+                continue;
+            }
+            const oldTokens = docTokens[doc.id];
+            if (oldTokens) {
+                engine.removeDocument(oldTokens);
+            }
+            engine.addDocument(doc.content);
+            docHashes[doc.id] = hash;
+            docTokens[doc.id] = uniqueTokens(doc.content);
+            changed = true;
+        }
+        if (changed) {
+            await this.persist(engine, docHashes, docTokens);
+        }
+        return engine;
+    }
+    /** Full rebuild: fresh engine, `addDocument` for every doc, persist a new snapshot. */
+    async rebuildFull(docs) {
+        const engine = new TFIDFEngine();
+        const docHashes = {};
+        const docTokens = {};
+        for (const doc of docs) {
+            engine.addDocument(doc.content);
+            docHashes[doc.id] = hashContent(doc.content);
+            docTokens[doc.id] = uniqueTokens(doc.content);
+        }
+        await this.persist(engine, docHashes, docTokens);
+        return engine;
+    }
+    async persist(engine, docHashes, docTokens) {
+        const state = {
+            schemaVersion: TFIDF_SCHEMA_VERSION,
+            docHashes,
+            docTokens,
+            tfidfState: engine.exportState(),
+        };
+        await withFileLock(this.filePath, async () => {
+            await writeJson(this.filePath, state);
+        });
+    }
+}
+//# sourceMappingURL=semantic-index-store.js.map

package/dist/storage/status-store/self-healing.js

@@ -110,7 +110,7 @@ export async function quarantineCorruptStatus(statusPath, projectPath) {
     }
     return { quarantinedAt: new Date().toISOString(), quarantinePath };
 }
-import { isNativeActive, fastScanSpecs } from '../../engine/core-bridge.js';
+import { fastScanSpecsAsync } from '../../engine/core-bridge.js';
 /**
  * Rebuild a fresh status.json by reading all spec.md frontmatters.
  * Returns the new ProjectStatus object (not written to disk — caller decides).
@@ -120,23 +120,21 @@ export async function rebuildStatusFromFrontmatters(params) {
     const byStatus = {};
     const byType = {};
     let totalSpecs = 0;
-    if (isNativeActive()) {
-        const briefs = fastScanSpecs(projectPath);
-        if (briefs) {
-            for (const b of briefs) {
-                totalSpecs++;
-                byStatus[b.status] = (byStatus[b.status] ?? 0) + 1;
-                byType[b.specType] = (byType[b.specType] ?? 0) + 1;
-            }
-            return {
-                updatedAt: new Date().toISOString(),
-                totalSpecs,
-                byStatus,
-                byType,
-                recentChanges: [],
-                version: PLANU_VERSION,
-            };
+    const { value: briefs } = await fastScanSpecsAsync(projectPath);
+    if (briefs) {
+        for (const b of briefs) {
+            totalSpecs++;
+            byStatus[b.status] = (byStatus[b.status] ?? 0) + 1;
+            byType[b.specType] = (byType[b.specType] ?? 0) + 1;
         }
+        return {
+            updatedAt: new Date().toISOString(),
+            totalSpecs,
+            byStatus,
+            byType,
+            recentChanges: [],
+            version: PLANU_VERSION,
+        };
     }
     const specsDir = join(projectPath, 'planu', 'specs');
     const byStatusResult = {};

package/dist/tools/challenge-spec/scenarios-utils.js

@@ -61,7 +61,11 @@ const CAPABILITY_SIGNALS = {
         /\b(?:email\s+address|phone\s+number|social\s+security\s+number)\b/i,
     ],
     events: [
-        /\b(?:process|handle|publish|consume)\w*(?:\s+[a-z0-9_-]+){0,3}\s+event\b/i,
+        // Negative lookahead excludes runtime compounds like "event-loop"/"event-driven": a
+        // hyphen right after "event" means the match is a prefix of a different word, not the
+        // noun "event" itself (SPEC-1262 — handler identifiers must not cross clause boundaries
+        // into unrelated event-loop prose).
+        /\b(?:process|handle|publish|consume)\w*(?:\s+[a-z0-9_-]+){0,3}\s+event\b(?!-)/i,
         /\b(?:event\s+(?:schema|contract|producer|consumer|handler|stream)|message\s+(?:broker|queue|consumer|producer))\b/i,
         /\b(?:kafka|rabbitmq|pubsub|nats|eventbridge|sqs|sns|dead[ -]?letter\s+queue|dlq)\b/i,
         /\b(?:publish|produce|consume)(?:es|d|r|rs|ing)?\s+(?:an?\s+)?(?:event|message)\b/i,

package/dist/tools/create-spec.js

@@ -17,7 +17,7 @@ import { generateLeanTechnicalContent, } from '../engine/spec-format/lean-techni
 import { extractFilesFromSpecBody } from '../engine/spec-format/technical-md-populator.js';
 import { buildCanonicalUnifiedSpecContent, validateUnifiedSpecCandidate, } from '../engine/spec-format/unified-spec-builder.js';
 import { buildImplementationContractSection } from '../engine/implementation-contract/index.js';
-import { validateEnglishOnlySpecText } from '../engine/spec-language/english-only.js';
+import { resolveEnglishOnlySpecGate } from '../engine/spec-language/english-only.js';
 import { FallbackGenerator } from '../engine/spec-generator/index.js';
 import { analyzeProjectForSpec, getEmptyAutopilotResult, } from './create-spec/autopilot-analyzer.js';
 import { trackCost } from '../engine/cost-tracking/operation-tracker.js';
@@ -880,28 +880,50 @@ function validateCreateSpecEnums(input) {
 }
 const DESCRIPTION_MAX_CHARS = 10_000;
 const DESCRIPTION_EXCEED_MSG = 'Description exceeds 10000 chars. Create with a summary (<3k) and use reconcile_spec to add the rest.';
-function checkEnglishOnlyInput(params) {
-    const validation = validateEnglishOnlySpecText(`${params.title}\n\n${params.description}`);
-    if (validation.ok) {
-        return null;
-    }
+/** SPEC-1342: Terminal rejection — only reached after one translation clarification round failed. */
+function buildEnglishGateRejectionResult(gate) {
     return {
         content: [
             {
                 type: 'text',
-                text: `English-only spec gate blocked create_spec.\n\n${validation.reason ?? 'Non-English prose detected.'}\n\n` +
+                text: `English-only spec gate blocked create_spec.\n\n${gate.reason ?? 'Non-English prose detected.'}\n\n` +
                     'Rewrite the title and description in English, then call create_spec again. User-facing responses may be localized, but spec.md must be English.',
             },
         ],
         isError: true,
         structuredContent: {
             error: 'SPEC_LANGUAGE_GATE_BLOCKED',
-            detectedLanguage: validation.detectedLanguage,
-            signals: validation.signals,
+            detectedLanguage: gate.originalLanguage,
             fixHint: 'Rewrite title and description in English before creating the spec.',
         },
     };
 }
+/**
+ * SPEC-1342: Apply an already-resolved English-only gate outcome. Returns:
+ * - `{ earlyReturn: null, englishTitle?, englishDescription? }` when the caller may proceed
+ *   (input was already English, or was successfully translated).
+ * - `{ earlyReturn: ToolResult }` when the caller must return early (translation clarification
+ *   question, or terminal rejection after one failed clarification round).
+ */
+function applyEnglishOnlyGate(gate) {
+    switch (gate.action) {
+        case 'ok':
+            return { earlyReturn: null };
+        case 'translated':
+            return {
+                earlyReturn: null,
+                englishTitle: gate.englishTitle,
+                englishDescription: gate.englishDescription,
+            };
+        case 'reject':
+            return { earlyReturn: buildEnglishGateRejectionResult(gate) };
+        case 'ask':
+            return {
+                earlyReturn: interactiveResult(gate.questions ?? [], 'The spec title/description are not in English. Provide the English translation ' +
+                    '(e.g. via AskUserQuestion), then retry create_spec with clarificationAnswers.', 'universal'),
+            };
+    }
+}
 function quotePosixShellArgument(value) {
     return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
@@ -1209,15 +1231,30 @@ export async function handleCreateSpec(inputParams, server) {
         inputParams.specId) {
         return handleAgentTeamSynthesis(inputParams.specId, resolvedPath, inputParams.agentTeamFindings);
     }
-    const languageGate = checkEnglishOnlyInput(resolvedInputParams);
-    if (languageGate) {
-        return languageGate;
-    }
-    // SPEC-584: Gate check — block if pending clarification token exists and no answers provided
+    // SPEC-584: Gate check — block if pending clarification token exists and no answers provided.
+    // Runs before the English-only gate so a second call with no translation answer hits the
+    // existing well-formed "must call AskUserQuestion" mandate instead of re-asking forever.
     const gateError = await runClarificationGate(resolvedPath, 'create_spec', inputParams.clarificationAnswers);
     if (gateError) {
         return gateError;
     }
+    // SPEC-1342: English-only gate — offers a translation clarification round instead of
+    // hard-rejecting non-English title/description.
+    const languageGateResult = resolveEnglishOnlySpecGate(resolvedInputParams.title, resolvedInputParams.description, resolvedInputParams.clarificationAnswers);
+    const languageGate = applyEnglishOnlyGate(languageGateResult);
+    if (languageGate.earlyReturn) {
+        if (languageGateResult.action === 'ask') {
+            await persistClarificationToken(languageGate.earlyReturn, hashProjectPath(resolvedPath), 'create_spec');
+        }
+        return languageGate.earlyReturn;
+    }
+    if (languageGate.englishTitle !== undefined) {
+        resolvedInputParams.title = languageGate.englishTitle;
+    }
+    if (languageGate.englishDescription !== undefined) {
+        resolvedInputParams.description = languageGate.englishDescription;
+    }
+    const originalLanguage = languageGateResult.originalLanguage;
     const idempotencyKey = computeIdempotencyKey(inputParams.title, resolvedPath, inputParams.idempotencyKey);
     const cutoff = Date.now() - IDEMPOTENCY_MATCH_WINDOW_MS;
     const storeOnlyCandidate = await findStoreByIdempotencyKey(hashProjectPath(resolvedPath), idempotencyKey, cutoff);
@@ -1571,7 +1608,15 @@ export async function handleCreateSpec(inputParams, server) {
                 if (!claimLifecycle.committed) {
                     throw new Error('create_spec critical path completed without a durable commit');
                 }
-                return finishRecoveredOperation(operationJournal, operationKey, criticalResult.value.data.committedResult);
+                const committedResult = criticalResult.value.data.committedResult;
+                // SPEC-1342: surface the original (pre-translation) language on the created spec's response.
+                if (originalLanguage && !committedResult.isError) {
+                    committedResult.structuredContent = {
+                        ...committedResult.structuredContent,
+                        originalLanguage,
+                    };
+                }
+                return finishRecoveredOperation(operationJournal, operationKey, committedResult);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);