@planu/cli 4.13.0 → 5.0.0

package/dist/engine/telemetry/health-checker.js

@@ -2,16 +2,18 @@
 // engine/telemetry/health-checker.ts — SPEC-346: Diagnose why telemetry data is not reaching the dashboard.
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { readTelemetryConfig } from './telemetry-store.js';
+import { isTelemetryEnabled } from './telemetry-store.js';
 import { sendTelemetryEvent } from './telemetry-client.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
+import { networkFetch, withNetworkConsent } from '../network-policy.js';
 const NETWORK_TIMEOUT_MS = 5_000;
 const RECENT_EVENT_THRESHOLD_DAYS = 7;
 // ---------------------------------------------------------------------------
 // Individual checks
 // ---------------------------------------------------------------------------
 async function checkConfigEnabled() {
-    const config = await readTelemetryConfig();
-    if (!config?.enabled) {
+    const enabled = await isTelemetryEnabled();
+    if (!enabled) {
         return {
             check: {
                 name: 'config-enabled',
@@ -31,19 +33,46 @@ async function checkConfigEnabled() {
     };
 }
 function checkEndpointConfigured(endpoint) {
-    if (!endpoint || endpoint.trim() === '') {
+    if (!isValidTelemetryEndpoint(endpoint)) {
         return {
             name: 'endpoint-configured',
             status: 'fail',
-            detail: 'No telemetry endpoint configured. Set PLANU_TELEMETRY_ENDPOINT env var.',
+            detail: 'Telemetry endpoint is missing or invalid. Use HTTPS, or HTTP only for an explicit loopback host.',
         };
     }
     return {
         name: 'endpoint-configured',
         status: 'ok',
-        detail: `Endpoint: ${endpoint}`,
+        detail: 'Telemetry endpoint configured',
     };
 }
+function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]';
+}
+function isValidTelemetryEndpoint(endpoint) {
+    if (!endpoint || endpoint.trim() === '') {
+        return false;
+    }
+    try {
+        const parsed = new URL(endpoint.trim());
+        return (parsed.username === '' &&
+            parsed.password === '' &&
+            (parsed.protocol === 'https:' ||
+                (parsed.protocol === 'http:' && isLoopbackHost(parsed.hostname))));
+    }
+    catch {
+        return false;
+    }
+}
+function checkTokenConfigured(token) {
+    return token?.trim()
+        ? { name: 'token-configured', status: 'ok', detail: 'Telemetry token configured' }
+        : {
+            name: 'token-configured',
+            status: 'fail',
+            detail: 'Telemetry token is missing. Set PLANU_TELEMETRY_TOKEN env var.',
+        };
+}
 async function checkNetworkReachable(endpoint) {
     if (!endpoint) {
         return {
@@ -53,10 +82,10 @@ async function checkNetworkReachable(endpoint) {
         };
     }
     try {
-        const response = await fetch(endpoint, {
+        const response = await withNetworkConsent('telemetry', (receipt) => networkFetch(receipt, endpoint, {
             method: 'GET',
             signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
-        });
+        }));
         if (response.ok || response.status < 500) {
             return {
                 name: 'network-reachable',
@@ -80,11 +109,7 @@ async function checkNetworkReachable(endpoint) {
     }
 }
 async function checkLastEvent(projectPath) {
-    const candidates = [
-        join(projectPath, 'data', 'telemetry-events.json'),
-        join(projectPath, '.planu', 'telemetry-events.json'),
-        join(projectPath, 'data', 'telemetry.json'),
-    ];
+    const candidates = [join(projectDataDir(hashProjectPath(projectPath)), 'telemetry-events.json')];
     for (const candidate of candidates) {
         try {
             const raw = await readFile(candidate, 'utf-8');
@@ -126,10 +151,7 @@ async function checkLastEvent(projectPath) {
     };
 }
 async function checkErrorLog(projectPath) {
-    const candidates = [
-        join(projectPath, 'data', 'telemetry-errors.json'),
-        join(projectPath, '.planu', 'telemetry-errors.json'),
-    ];
+    const candidates = [join(projectDataDir(hashProjectPath(projectPath)), 'telemetry-errors.json')];
     for (const candidate of candidates) {
         try {
             const raw = await readFile(candidate, 'utf-8');
@@ -196,7 +218,7 @@ async function checkClientVersion(projectPath) {
 // ---------------------------------------------------------------------------
 // Test event
 // ---------------------------------------------------------------------------
-function sendTestDiagnosticEvent(installationId) {
+function sendTestDiagnosticEvent() {
     sendTelemetryEvent({
         event: 'tool_used',
         properties: {
@@ -204,7 +226,6 @@ function sendTestDiagnosticEvent(installationId) {
             diagnostic: true,
             timestamp: new Date().toISOString(),
         },
-        installationId,
     });
 }
 // ---------------------------------------------------------------------------
@@ -215,7 +236,7 @@ function buildRecommendation(status) {
         case 'disabled':
             return 'Run configure_telemetry to enable usage tracking';
         case 'misconfigured':
-            return 'Set PLANU_TELEMETRY_ENDPOINT or run configure_telemetry';
+            return 'Set valid PLANU_TELEMETRY_ENDPOINT and PLANU_TELEMETRY_TOKEN values.';
         case 'degraded':
             return 'Check network connectivity or firewall rules blocking outbound requests';
         case 'healthy':
@@ -239,8 +260,8 @@ function computeStatus(isEnabled, checks) {
     if (!isEnabled) {
         return 'disabled';
     }
-    const endpointCheck = checks.find((c) => c.name === 'endpoint-configured');
-    if (endpointCheck?.status === 'fail') {
+    const configurationChecks = checks.filter((check) => check.name === 'endpoint-configured' || check.name === 'token-configured');
+    if (configurationChecks.some((check) => check.status === 'fail')) {
         return 'misconfigured';
     }
     const hasWarn = checks.some((c) => c.status === 'warn');
@@ -264,29 +285,35 @@ export async function checkTelemetryHealth(projectPath, options) {
             humanSummary: buildHumanSummary(status, checks),
         };
     }
-    // Default endpoint from telemetry-client
-    const defaultEndpoint = 'https://canusqigtzldstnjddio.supabase.co/rest/v1/telemetry_events';
-    const endpoint = process.env.PLANU_TELEMETRY_ENDPOINT?.trim() ?? defaultEndpoint;
+    const endpoint = process.env.PLANU_TELEMETRY_ENDPOINT?.trim();
+    const token = process.env.PLANU_TELEMETRY_TOKEN;
+    const endpointCheck = checkEndpointConfigured(endpoint ?? '');
+    const tokenCheck = checkTokenConfigured(token);
+    const configured = endpointCheck.status === 'ok' && tokenCheck.status === 'ok';
     const [networkCheck, lastEventCheck, errorLogCheck, versionCheck] = await Promise.all([
-        checkNetworkReachable(endpoint),
+        configured
+            ? checkNetworkReachable(endpoint ?? '')
+            : Promise.resolve({
+                name: 'network-reachable',
+                status: 'skip',
+                detail: 'Skipped until endpoint and token configuration is valid',
+            }),
         checkLastEvent(projectPath),
         checkErrorLog(projectPath),
         checkClientVersion(projectPath),
     ]);
-    const endpointCheck = checkEndpointConfigured(endpoint);
     const checks = [
         enabledCheck,
         endpointCheck,
+        tokenCheck,
         networkCheck,
         lastEventCheck,
         errorLogCheck,
         versionCheck,
     ];
     const status = computeStatus(enabled, checks);
-    if (options?.sendTestEvent === true) {
-        const config = await readTelemetryConfig();
-        const installationId = config?.installationId ?? 'anonymous';
-        sendTestDiagnosticEvent(installationId);
+    if (options?.sendTestEvent === true && configured) {
+        sendTestDiagnosticEvent();
     }
     return {
         status,

package/dist/engine/telemetry/index.d.ts

@@ -1,5 +1,4 @@
 export * from './telemetry-store.js';
 export * from './telemetry-client.js';
 export * from './health-checker.js';
-export { resolveGeo, resetGeoCache } from './geo-resolver.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/telemetry/index.js

@@ -2,5 +2,4 @@
 export * from './telemetry-store.js';
 export * from './telemetry-client.js';
 export * from './health-checker.js';
-export { resolveGeo, resetGeoCache } from './geo-resolver.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/telemetry/stance.js

@@ -1,6 +1,7 @@
 // engine/telemetry/stance.ts — Telemetry opt-in stance reader (SPEC-741)
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { TELEMETRY_CONSENT_VERSION } from './telemetry-store.js';
 /**
  * Returns true if telemetry is enabled for the given project root.
  * Reads conventions.json synchronously.
@@ -11,7 +12,7 @@ export function isTelemetryEnabled(projectRoot) {
         return false;
     }
     if (process.env.PLANU_TELEMETRY === 'on') {
-        return true;
+        return process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION);
     }
     try {
         const conventionsPath = join(projectRoot, 'planu', 'conventions.json');
@@ -21,7 +22,7 @@ export function isTelemetryEnabled(projectRoot) {
         const raw = readFileSync(conventionsPath, 'utf-8');
         const parsed = JSON.parse(raw);
         const telemetry = parsed.telemetry;
-        return telemetry?.enabled === true;
+        return telemetry?.enabled === true && telemetry.consentVersion === TELEMETRY_CONSENT_VERSION;
     }
     catch {
         return false;

package/dist/engine/telemetry/telemetry-client.d.ts

@@ -1,8 +1,4 @@
 import type { TelemetryEvent } from '../../types/index.js';
-/**
- * Send a telemetry event to Supabase. Fire-and-forget — never awaited by callers.
- * Enriches events with geo data (country/timezone) from a cached IP lookup.
- * No PII: properties must not contain paths, emails, or user identifiers.
- */
+/** Fire-and-forget; absence or staleness of opt-in prevents any network access. */
 export declare function sendTelemetryEvent(event: TelemetryEvent): void;
 //# sourceMappingURL=telemetry-client.d.ts.map

package/dist/engine/telemetry/telemetry-client.js

@@ -1,44 +1,78 @@
-// engine/telemetry/telemetry-client.ts — SPEC-200: Fire-and-forget telemetry POST to Supabase.
-// Never throws — all errors are silently swallowed to avoid blocking tool responses.
-import { resolveGeo } from './geo-resolver.js';
-const SUPABASE_URL = 'https://canusqigtzldstnjddio.supabase.co';
-const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNhbnVzcWlndHpsZHN0bmpkZGlvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzI3NTk2MjgsImV4cCI6MjA4ODMzNTYyOH0.Thw1Xgf9_iabOD75J00u35d2k5NsIpUBU9PrqOShxMU';
-const TELEMETRY_ENDPOINT = `${SUPABASE_URL}/rest/v1/telemetry_events`;
-/**
- * Send a telemetry event to Supabase. Fire-and-forget — never awaited by callers.
- * Enriches events with geo data (country/timezone) from a cached IP lookup.
- * No PII: properties must not contain paths, emails, or user identifiers.
- */
+// Remote telemetry is disabled by default and always crosses consent + redaction boundaries.
+import { networkFetch, withNetworkConsent } from '../network-policy.js';
+import { redactSensitiveValue } from '../../security/redactor.js';
+import { isTelemetryEnabled } from './telemetry-store.js';
+function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]';
+}
+function isValidTelemetryEndpoint(endpoint) {
+    if (!endpoint || endpoint.trim() === '') {
+        return false;
+    }
+    try {
+        const parsed = new URL(endpoint.trim());
+        return (parsed.username === '' &&
+            parsed.password === '' &&
+            (parsed.protocol === 'https:' ||
+                (parsed.protocol === 'http:' && isLoopbackHost(parsed.hostname))));
+    }
+    catch {
+        return false;
+    }
+}
+function isConfiguredTelemetryToken(token) {
+    return Boolean(token?.trim());
+}
+const ALLOWED_PROPERTIES = new Set([
+    'allowed',
+    'context',
+    'diagnostic',
+    'duplicateCount',
+    'durationMs',
+    'errorClass',
+    'errorType',
+    'framework',
+    'freeGBObserved',
+    'language',
+    'nodeVersion',
+    'planVersion',
+    'platform',
+    'pressureLevel',
+    'requested',
+    'specCount',
+    'stack',
+    'timestamp',
+    'tool',
+]);
+function safeProperties(properties) {
+    const allowlisted = Object.fromEntries(Object.entries(properties).filter(([key]) => ALLOWED_PROPERTIES.has(key)));
+    const redacted = redactSensitiveValue(allowlisted);
+    return redacted !== null && typeof redacted === 'object' && !Array.isArray(redacted)
+        ? redacted
+        : {};
+}
+/** Fire-and-forget; absence or staleness of opt-in prevents any network access. */
 export function sendTelemetryEvent(event) {
-    // Enrich with geo data asynchronously, then send
-    resolveGeo()
-        .then((geo) => {
-        const properties = geo
-            ? {
-                ...event.properties,
-                country: geo.countryCode,
-                timezone: geo.timezone,
-            }
-            : event.properties;
-        const payload = {
-            event_name: event.event,
-            properties,
-            installation_id: event.installationId,
-        };
-        return fetch(TELEMETRY_ENDPOINT, {
+    void isTelemetryEnabled()
+        .then((enabled) => {
+        const endpoint = process.env.PLANU_TELEMETRY_ENDPOINT?.trim();
+        const token = process.env.PLANU_TELEMETRY_TOKEN?.trim();
+        if (!enabled || !isValidTelemetryEndpoint(endpoint) || !isConfiguredTelemetryToken(token)) {
+            return undefined;
+        }
+        return withNetworkConsent('telemetry', (receipt) => networkFetch(receipt, endpoint, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                apikey: SUPABASE_ANON_KEY,
-                Authorization: `Bearer ${SUPABASE_ANON_KEY}`,
-                Prefer: 'return=minimal',
+                Authorization: `Bearer ${token}`,
             },
-            body: JSON.stringify(payload),
+            body: JSON.stringify({
+                event_name: event.event,
+                properties: safeProperties(event.properties),
+            }),
             signal: AbortSignal.timeout(5_000),
-        });
+        }));
     })
-        .catch(() => {
-        // Silently swallow all errors — telemetry must never break the tool
-    });
+        .catch(() => undefined);
 }
 //# sourceMappingURL=telemetry-client.js.map

package/dist/engine/telemetry/telemetry-store.d.ts

@@ -1,11 +1,11 @@
 import type { TelemetryConfig } from '../../types/index.js';
+export declare const TELEMETRY_CONSENT_VERSION: 1;
 export declare function readTelemetryConfig(): Promise<TelemetryConfig | null>;
 export declare function writeTelemetryConfig(config: TelemetryConfig): Promise<void>;
-export declare function getOrCreateInstallationId(): Promise<string>;
 /**
  * Returns true if telemetry is enabled.
- * Default: ENABLED (opt-out model). Disable by setting PLANU_TELEMETRY=off
- * or by explicitly calling configure_telemetry with enabled=false.
+ * Default: disabled. Both environment and stored opt-ins are versioned so a
+ * changed privacy contract requires renewed consent.
  */
 export declare function isTelemetryEnabled(): Promise<boolean>;
 /** Returns true if the user has never been shown the opt-in prompt. */

package/dist/engine/telemetry/telemetry-store.js

@@ -3,14 +3,25 @@
 // Stores opt-in preference and installation ID outside the project directory.
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-const PLANU_DIR = join(homedir(), '.planu');
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const PLANU_DIR = resolveStorageLayout().config;
 const TELEMETRY_FILE = join(PLANU_DIR, 'telemetry.json');
+export const TELEMETRY_CONSENT_VERSION = 1;
 export async function readTelemetryConfig() {
     try {
         const raw = await readFile(TELEMETRY_FILE, 'utf-8');
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        const config = {
+            enabled: parsed.enabled === true,
+            promptedAt: typeof parsed.promptedAt === 'string' ? parsed.promptedAt : '',
+        };
+        if (typeof parsed.consentVersion === 'number') {
+            config.consentVersion = parsed.consentVersion;
+        }
+        if (parsed.enableObservatory === true) {
+            config.enableObservatory = true;
+        }
+        return config;
     }
     catch {
         return null;
@@ -18,32 +29,28 @@ export async function readTelemetryConfig() {
 }
 export async function writeTelemetryConfig(config) {
     await mkdir(PLANU_DIR, { recursive: true });
-    await writeFile(TELEMETRY_FILE, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-}
-export async function getOrCreateInstallationId() {
-    const config = await readTelemetryConfig();
-    if (config?.installationId) {
-        return config.installationId;
-    }
-    const id = randomUUID();
-    await writeTelemetryConfig({
-        enabled: false,
-        installationId: id,
-        promptedAt: '',
-    });
-    return id;
+    const safeConfig = {
+        enabled: config.enabled,
+        promptedAt: config.promptedAt,
+        consentVersion: config.consentVersion,
+        enableObservatory: config.enableObservatory,
+    };
+    await writeFile(TELEMETRY_FILE, JSON.stringify(safeConfig, null, 2) + '\n', 'utf-8');
 }
 /**
  * Returns true if telemetry is enabled.
- * Default: ENABLED (opt-out model). Disable by setting PLANU_TELEMETRY=off
- * or by explicitly calling configure_telemetry with enabled=false.
+ * Default: disabled. Both environment and stored opt-ins are versioned so a
+ * changed privacy contract requires renewed consent.
  */
 export async function isTelemetryEnabled() {
     if (process.env.PLANU_TELEMETRY === 'off') {
         return false;
     }
+    if (process.env.PLANU_TELEMETRY === 'on') {
+        return process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION);
+    }
     const config = await readTelemetryConfig();
-    return config?.enabled !== false; // default true unless explicitly disabled
+    return config?.enabled === true && config.consentVersion === TELEMETRY_CONSENT_VERSION;
 }
 /** Returns true if the user has never been shown the opt-in prompt. */
 export async function hasNeverBeenPrompted() {
@@ -53,11 +60,11 @@ export async function hasNeverBeenPrompted() {
 /** Mark that the user was shown the opt-in prompt (so we don't show it again). */
 export async function markAsPrompted() {
     const existing = await readTelemetryConfig();
-    const id = existing?.installationId ?? randomUUID();
     await writeTelemetryConfig({
         enabled: existing?.enabled ?? false,
-        installationId: id,
         promptedAt: new Date().toISOString(),
+        consentVersion: existing?.consentVersion,
+        enableObservatory: existing?.enableObservatory,
     });
 }
 //# sourceMappingURL=telemetry-store.js.map

package/dist/engine/test-framework-detector/detectors.js

@@ -1,11 +1,10 @@
-// engine/test-framework-detector/detectors.ts — SPEC-018
-// Individual testing framework detectors. Pure functions — no I/O.
+import { technologyValue } from '../technology-registry.js';
 // === Unit test framework detection ===
 const TESTING_FRAMEWORK_DEPS = [
-    ['vitest', 'vitest'],
-    ['jest', 'jest'],
+    [technologyValue('technology-vitest-a9127f'), technologyValue('technology-vitest-a9127f')],
+    [technologyValue('technology-jest-35e99f'), technologyValue('technology-jest-35e99f')],
     ['mocha', 'mocha'],
-    ['pytest', 'pytest'],
+    [technologyValue('technology-pytest-2b0121'), technologyValue('technology-pytest-2b0121')],
     ['junit', 'junit'],
     ['xunit', 'xunit'],
     ['rspec', 'rspec'],
@@ -207,7 +206,8 @@ export function detectVisualRegFramework(deps, files) {
         }
     }
     // Playwright with toMatchSnapshot is detected by playwright presence + snapshot usage
-    if (depSet.has('@playwright/test') || depSet.has('playwright')) {
+    if (depSet.has('@playwright/test') ||
+        depSet.has(technologyValue('technology-playwright-7827e8'))) {
         return 'playwright-snapshot';
     }
     return null;
@@ -215,8 +215,8 @@ export function detectVisualRegFramework(deps, files) {
 // === Test double pattern detection ===
 const TEST_DOUBLE_DEP_MAP = [
     ['sinon', 'sinon-stub'],
-    ['vitest', 'vitest-mock'],
-    ['jest', 'jest-mock'],
+    [technologyValue('technology-vitest-a9127f'), 'vitest-mock'],
+    [technologyValue('technology-jest-35e99f'), 'jest-mock'],
 ];
 export function detectTestDoublePattern(deps, fileContents) {
     const depSet = new Set(deps.map((d) => d.toLowerCase()));

package/dist/engine/test-framework-detector/strategy.js

@@ -1,7 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/test-framework-detector/strategy.ts — SPEC-018
-// Test strategy selection and full ecosystem detection.
+import { technologyValue } from '../technology-registry.js';
 import { detectTestingFramework, detectBDDFramework, detectPropertyTestFramework, detectLoadTestFramework, detectChaosFramework, detectVisualRegFramework, detectMutationFramework, detectTestDoublePattern, } from './detectors.js';
 /**
  * Select the appropriate test strategy based on project type and stack.
@@ -9,14 +6,16 @@ import { detectTestingFramework, detectBDDFramework, detectPropertyTestFramework
 export function selectTestStrategy(projectType, stack) {
     const stackSet = new Set(stack.map((s) => s.toLowerCase()));
     // Microservices → Honeycomb (more integration, minimal unit and E2E)
-    if (projectType === 'microservices' || stackSet.has('kubernetes') || stackSet.has('docker')) {
+    if (projectType === 'microservices' ||
+        stackSet.has(technologyValue('technology-kubernetes-94abcb')) ||
+        stackSet.has(technologyValue('technology-docker-d548c5'))) {
         return 'honeycomb';
     }
     // Frontend frameworks → Testing Trophy (more integration than unit)
-    if (stackSet.has('react') ||
-        stackSet.has('vue') ||
-        stackSet.has('angular') ||
-        stackSet.has('svelte') ||
+    if (stackSet.has(technologyValue('technology-react-275976')) ||
+        stackSet.has(technologyValue('technology-vue-564382')) ||
+        stackSet.has(technologyValue('technology-angular-a39f89')) ||
+        stackSet.has(technologyValue('technology-svelte-c190ac')) ||
         projectType === 'frontend') {
         return 'testing-trophy';
     }

package/dist/engine/test-generators/agent-test-templates.js

@@ -1,5 +1,4 @@
-// Planu — Agent Test Templates
-// SPEC-016a criteria 6 and 20: AI agent test scaffolds.
+import { technologyValue } from '../technology-registry.js';
 import { generatePytestAgentContent } from './agent-test-pytest.js';
 // === Test Definitions (criterion 6) ===
 /**
@@ -82,7 +81,7 @@ export function generateAgentTestDefs(title, testDir) {
  */
 export function generateAgentTestContent(title, testFramework) {
     const slug = title.toLowerCase().replace(/[^a-z0-9]/g, '-');
-    if (testFramework === 'pytest') {
+    if (testFramework === technologyValue('technology-pytest-2b0121')) {
         return generatePytestAgentContent(title, slug);
     }
     return generateVitestAgentContent(title, slug);

package/dist/engine/test-generators/contract-test-generator.d.ts

@@ -13,7 +13,7 @@ export declare function buildSampleEndpoints(_specTitle: string): ContractSpecEn
  * Generate a contract spec for the given spec title and knowledge.
  * Format is auto-detected from project stack.
  */
-export declare function generateContractSpec(specTitle: string, knowledge: ProjectKnowledge): ContractSpec;
+export declare function generateContractSpec(_specTitle: string, knowledge: ProjectKnowledge): ContractSpec;
 /**
  * Get the file extension for a given contract format.
  */