@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/server/runtimeMode.d.ts

@@ -1,4 +1,4 @@
 export type RuntimeMode = 'local' | 'cloud';
 export type DatabaseProvider = 'sqlite' | 'postgres';
-export declare function resolveRuntimeModeFromEnv(env?: NodeJS.ProcessEnv, fallbackProvider?: 'sqlite' | 'postgres'): RuntimeMode;
+export declare function resolveRuntimeModeFromEnv(env?: NodeJS.ProcessEnv, _fallbackProvider?: 'sqlite' | 'postgres'): RuntimeMode;
 export declare function assertCloudDatabaseProvider(runtimeMode: RuntimeMode, provider: DatabaseProvider, env?: NodeJS.ProcessEnv): void;

package/dist/server/runtimeMode.js

@@ -1,21 +1,6 @@
-function normalizeMode(raw) {
-    const normalized = String(raw || '').trim().toLowerCase();
-    if (normalized === 'local')
-        return 'local';
-    if (normalized === 'cloud')
-        return 'cloud';
-    return null;
-}
-export function resolveRuntimeModeFromEnv(env = process.env, fallbackProvider) {
-    const explicit = normalizeMode(env.TASKFORCE_RUNTIME_MODE);
-    if (explicit)
-        return explicit;
-    // Hosted deployments commonly use postgres and may omit an explicit runtime env.
-    // Keep provider-based fallback for compatibility, while still allowing explicit
-    // TASKFORCE_RUNTIME_MODE=local to force local behavior.
-    if (fallbackProvider === 'postgres')
-        return 'cloud';
-    return 'local';
+import { resolveDeploymentConfig } from '../config/deployment.js';
+export function resolveRuntimeModeFromEnv(env = process.env, _fallbackProvider) {
+    return resolveDeploymentConfig(env).runtimeMode;
 }
 export function assertCloudDatabaseProvider(runtimeMode, provider, env = process.env) {
     const allowSqliteInCloud = String(env.TASKFORCE_ALLOW_SQLITE_IN_CLOUD || '').trim().toLowerCase() === 'true';

package/dist/server/runtimeMode.test.js

@@ -4,14 +4,14 @@ describe('server/runtimeMode', () => {
     it('defaults to local when unset and sqlite fallback', () => {
         expect(resolveRuntimeModeFromEnv({}, 'sqlite')).toBe('local');
     });
-    it('falls back to cloud when postgres provider is set', () => {
-        expect(resolveRuntimeModeFromEnv({ TASKFORCE_DB_PROVIDER: 'postgres' }, 'postgres')).toBe('cloud');
+    it('does not infer cloud runtime from postgres provider', () => {
+        expect(resolveRuntimeModeFromEnv({ TASKFORCE_DB_PROVIDER: 'postgres' }, 'postgres')).toBe('local');
     });
     it('honors explicit TASKFORCE_RUNTIME_MODE override', () => {
         expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'local', TASKFORCE_DB_PROVIDER: 'postgres' })).toBe('local');
         expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'cloud', TASKFORCE_DB_PROVIDER: 'sqlite' })).toBe('cloud');
     });
-    it('keeps explicit local override even when postgres fallback is provided', () => {
+    it('keeps explicit local override even when postgres is configured', () => {
         expect(resolveRuntimeModeFromEnv({ TASKFORCE_RUNTIME_MODE: 'local', TASKFORCE_DB_PROVIDER: 'postgres' }, 'postgres')).toBe('local');
     });
     it('rejects sqlite provider in cloud runtime by default', () => {

package/dist/server/securityHeaders.d.ts

@@ -1,3 +1,3 @@
 import type { ServerResponse } from 'http';
 import type { RuntimeMode } from './runtimeMode.js';
-export declare function applySecurityHeaders(res: ServerResponse, runtimeMode: RuntimeMode): void;
+export declare function applySecurityHeaders(res: ServerResponse, runtimeMode: RuntimeMode, env?: NodeJS.ProcessEnv): void;

package/dist/server/securityHeaders.js

@@ -1,15 +1,74 @@
-export function applySecurityHeaders(res, runtimeMode) {
+import { resolveDeploymentConfig } from '../config/deployment.js';
+import { TASKFORCE_CLOUD_ENVIRONMENTS } from '../config/cloudEnvironment.js';
+import { resolveObjectStorageConfigFromEnv } from '../storage/objectStorageConfig.js';
+function normalizeCspSourceFromUrl(raw) {
+    const value = String(raw || '').trim();
+    if (!value)
+        return '';
+    try {
+        return new URL(value).origin;
+    }
+    catch {
+        return '';
+    }
+}
+function toWsOrigin(httpOrigin) {
+    if (httpOrigin.startsWith('https://'))
+        return `wss://${httpOrigin.slice('https://'.length)}`;
+    if (httpOrigin.startsWith('http://'))
+        return `ws://${httpOrigin.slice('http://'.length)}`;
+    return '';
+}
+export function applySecurityHeaders(res, runtimeMode, env = process.env) {
+    const cloudflareInsightsScriptOrigin = 'https://static.cloudflareinsights.com';
+    const cloudflareInsightsBeaconOrigin = 'https://cloudflareinsights.com';
+    const connectSrc = new Set([
+        "'self'",
+        'https://api.stripe.com',
+        cloudflareInsightsBeaconOrigin
+    ]);
+    const imgSrc = new Set([
+        "'self'",
+        'data:',
+        'blob:'
+    ]);
+    const deployment = resolveDeploymentConfig(env);
+    const fallbackCloudBaseUrl = deployment.cloudBaseUrl || TASKFORCE_CLOUD_ENVIRONMENTS.production.appBaseUrl;
+    const cloudAuthOrigin = normalizeCspSourceFromUrl(deployment.cloudAuthBaseUrl || fallbackCloudBaseUrl);
+    const cloudProxyOrigin = normalizeCspSourceFromUrl(env.TASKFORCE_CLOUD_PROXY_BASE_URL || fallbackCloudBaseUrl);
+    const wsOrigin = normalizeCspSourceFromUrl(deployment.wsBaseUrl || fallbackCloudBaseUrl);
+    for (const origin of [cloudAuthOrigin, cloudProxyOrigin, wsOrigin]) {
+        if (!origin)
+            continue;
+        connectSrc.add(origin);
+        const mappedWsOrigin = toWsOrigin(origin);
+        if (mappedWsOrigin)
+            connectSrc.add(mappedWsOrigin);
+    }
+    try {
+        const objectStorage = resolveObjectStorageConfigFromEnv(env);
+        if (objectStorage.provider === 'r2' && objectStorage.r2) {
+            const r2Origin = normalizeCspSourceFromUrl(objectStorage.r2.endpoint);
+            if (r2Origin) {
+                connectSrc.add(r2Origin);
+                imgSrc.add(r2Origin);
+            }
+        }
+    }
+    catch {
+        // Ignore incomplete object storage env during header generation.
+    }
     const cspDirectives = [
         "default-src 'self'",
         "base-uri 'self'",
         "frame-ancestors 'none'",
         "object-src 'none'",
-        "connect-src 'self' https://api.stripe.com",
+        `connect-src ${Array.from(connectSrc).join(' ')}`,
         "frame-src 'self' https://js.stripe.com https://hooks.stripe.com",
-        "script-src 'self' https://js.stripe.com",
-        "img-src 'self' data: blob:",
-        "style-src 'self' 'unsafe-inline'",
-        "font-src 'self' data:"
+        `script-src 'self' https://js.stripe.com ${cloudflareInsightsScriptOrigin}`,
+        `img-src ${Array.from(imgSrc).join(' ')}`,
+        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",
+        "font-src 'self' data: https://fonts.gstatic.com"
     ];
     res.setHeader('Content-Security-Policy', cspDirectives.join('; '));
     res.setHeader('X-Content-Type-Options', 'nosniff');

package/dist/server/securityHeaders.test.js

@@ -13,10 +13,14 @@ function mockRes() {
 describe('server security headers', () => {
     it('applies baseline security headers in local mode', () => {
         const res = mockRes();
-        applySecurityHeaders(res, 'local');
+        applySecurityHeaders(res, 'local', {});
         expect(res.getHeader('X-Content-Type-Options')).toBe('nosniff');
         expect(res.getHeader('Content-Security-Policy')).toContain("connect-src 'self' https://api.stripe.com");
+        expect(res.getHeader('Content-Security-Policy')).toContain('https://cloudflareinsights.com');
         expect(res.getHeader('Content-Security-Policy')).toContain("frame-src 'self' https://js.stripe.com https://hooks.stripe.com");
+        expect(res.getHeader('Content-Security-Policy')).toContain("script-src 'self' https://js.stripe.com https://static.cloudflareinsights.com");
+        expect(res.getHeader('Content-Security-Policy')).toContain("style-src 'self' 'unsafe-inline' https://fonts.googleapis.com");
+        expect(res.getHeader('Content-Security-Policy')).toContain("font-src 'self' data: https://fonts.gstatic.com");
         expect(res.getHeader('X-Frame-Options')).toBe('DENY');
         expect(res.getHeader('Referrer-Policy')).toBe('strict-origin-when-cross-origin');
         expect(res.getHeader('Permissions-Policy')).toBe('camera=(), microphone=(), geolocation=(), payment=()');
@@ -24,9 +28,43 @@ describe('server security headers', () => {
         expect(res.getHeader('Cross-Origin-Resource-Policy')).toBe('same-origin');
         expect(res.getHeader('Strict-Transport-Security')).toBeUndefined();
     });
+    it('includes configured cloud auth/proxy/ws origins in connect-src', () => {
+        const res = mockRes();
+        applySecurityHeaders(res, 'local', {
+            TASKFORCE_CLOUD_ENVIRONMENT: 'performance',
+            VITE_TASKFORCE_CLOUD_AUTH_BASE_URL: 'https://performance-app.taskforcehq.ai',
+            TASKFORCE_CLOUD_PROXY_BASE_URL: 'https://staging-app.taskforcehq.ai',
+            VITE_TASKFORCE_WS_BASE_URL: 'wss://performance-app.taskforcehq.ai'
+        });
+        const csp = String(res.getHeader('Content-Security-Policy') || '');
+        expect(csp).toContain('https://performance-app.taskforcehq.ai');
+        expect(csp).toContain('https://staging-app.taskforcehq.ai');
+        expect(csp).toContain('wss://performance-app.taskforcehq.ai');
+    });
+    it('includes the canonical cloud environment origin when only TASKFORCE_CLOUD_ENVIRONMENT is set', () => {
+        const res = mockRes();
+        applySecurityHeaders(res, 'local', {
+            TASKFORCE_CLOUD_ENVIRONMENT: 'staging'
+        });
+        const csp = String(res.getHeader('Content-Security-Policy') || '');
+        expect(csp).toContain('https://staging-app.taskforcehq.ai');
+    });
+    it('includes the R2 endpoint origin in connect-src and img-src when object storage provider is r2', () => {
+        const res = mockRes();
+        applySecurityHeaders(res, 'cloud', {
+            TASKFORCE_OBJECT_STORAGE_PROVIDER: 'r2',
+            R2_ACCOUNT_ID: '49f2543c00ad6d664cc214b0b85c46a3',
+            R2_BUCKET: 'taskforce-perf-assets',
+            R2_ACCESS_KEY_ID: 'test-access-key',
+            R2_SECRET_ACCESS_KEY: 'test-secret'
+        });
+        const csp = String(res.getHeader('Content-Security-Policy') || '');
+        expect(csp).toContain('https://49f2543c00ad6d664cc214b0b85c46a3.r2.cloudflarestorage.com');
+        expect(csp).toContain("img-src 'self' data: blob: https://49f2543c00ad6d664cc214b0b85c46a3.r2.cloudflarestorage.com");
+    });
     it('adds HSTS in cloud mode', () => {
         const res = mockRes();
-        applySecurityHeaders(res, 'cloud');
+        applySecurityHeaders(res, 'cloud', {});
         expect(res.getHeader('Strict-Transport-Security')).toBe('max-age=31536000; includeSubDomains');
     });
 });

package/dist/services/templateEngine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{__tests__ → services}/templateEngine.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { TemplateEngine } from '../services/templateEngine';
+import { TemplateEngine } from './templateEngine';
 import fs from 'fs';
 // Explicitly mock fs
 vi.mock('fs', () => ({

package/dist/services/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{__tests__ → services}/templates.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { TemplateEngine } from '../services/templateEngine';
+import { TemplateEngine } from './templateEngine';
 import path from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));

package/dist/services/workflowDocumentFixtures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{__tests__ → services}/workflowDocumentFixtures.test.js

@@ -22,7 +22,7 @@ function assertOrderedAndNonEmpty(content, headings) {
 }
 describe('Workflow document fixtures', () => {
     it('sample implementation plan is complete and valid for attach', () => {
-        const relativePath = '.taskforce/task-data/task-1/implementation_plans/implementation-plan.md';
+        const relativePath = '.taskforce/docs/implementation_plans/implementation-plan.md';
         const content = fs.readFileSync(path.join(fixturesDir, 'sample-implementation-plan.md'), 'utf8');
         expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
         assertOrderedAndNonEmpty(content, [
@@ -34,7 +34,7 @@ describe('Workflow document fixtures', () => {
         ]);
     });
     it('sample evaluation is complete and valid for attach', () => {
-        const relativePath = '.taskforce/task-data/task-1/evaluations/evaluation.md';
+        const relativePath = '.taskforce/docs/evaluations/evaluation.md';
         const content = fs.readFileSync(path.join(fixturesDir, 'sample-evaluation.md'), 'utf8');
         expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
         assertOrderedAndNonEmpty(content, [
@@ -48,7 +48,7 @@ describe('Workflow document fixtures', () => {
         ]);
     });
     it('sample review is complete and valid for attach', () => {
-        const relativePath = '.taskforce/task-data/task-1/reviews/review.md';
+        const relativePath = '.taskforce/docs/reviews/review.md';
         const content = fs.readFileSync(path.join(fixturesDir, 'sample-review.md'), 'utf8');
         expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
         assertOrderedAndNonEmpty(content, [
@@ -61,7 +61,7 @@ describe('Workflow document fixtures', () => {
         ]);
     });
     it('sample collaboration blueprint is complete and valid for attach', () => {
-        const relativePath = '.taskforce/task-data/task-1/collaborations/collaboration-blueprint.md';
+        const relativePath = '.taskforce/docs/collaborations/collaboration-blueprint.md';
         const content = fs.readFileSync(path.join(fixturesDir, 'sample-collaboration-blueprint.md'), 'utf8');
         expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
         assertOrderedAndNonEmpty(content, [

package/dist/services/workflowExportMatrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{__tests__ → services}/workflowExportMatrix.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { TemplateEngine } from '../services/templateEngine';
+import { TemplateEngine } from './templateEngine';
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';

package/dist/services/workflowExportSnapshots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/workflowGeneration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/workflowSimulation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/workflowSimulation.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+const workflowsDir = path.resolve(process.cwd(), 'src/resources/templates/workflows');
+function loadWorkflow(name) {
+    const raw = fs.readFileSync(path.join(workflowsDir, `${name}.yaml`), 'utf8');
+    return yaml.load(raw);
+}
+function buildAliasMap(names) {
+    const map = new Map();
+    for (const name of names) {
+        const workflow = loadWorkflow(name);
+        for (const alias of workflow.dispatch?.aliases || []) {
+            map.set(alias, name);
+        }
+    }
+    return map;
+}
+function simulateDoDispatch(params) {
+    const doWorkflow = loadWorkflow('do');
+    const aliasMap = buildAliasMap(['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review']);
+    const calls = [];
+    if (params.knownTaskId) {
+        calls.push({ tool: 'get_task' });
+    }
+    else {
+        calls.push({ tool: 'list_tasks' });
+        calls.push({ tool: 'get_task' });
+    }
+    const explicitRoute = aliasMap.get(params.command);
+    if (explicitRoute && explicitRoute !== 'do') {
+        return { routedTo: explicitRoute, calls };
+    }
+    const mapped = params.approach ? doWorkflow.dispatch?.approachMap?.[params.approach] : undefined;
+    return {
+        routedTo: mapped || doWorkflow.dispatch?.default || 'execute',
+        calls
+    };
+}
+function simulateExecuteFlow(params) {
+    const calls = [{ tool: 'update_task', args: { status: 'in-progress' } }];
+    const requested = params.explicitFinalStatus;
+    if (!requested) {
+        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
+        calls.push({ tool: 'update_task', args: { status: 'review' } });
+        return calls;
+    }
+    if ((requested === 'done' || requested === 'cancelled') && !params.explicitUserInstructionForDoneOrCancelled) {
+        throw new Error('Blocked unsafe status transition');
+    }
+    if (requested === 'task' || requested === 'on-hold') {
+        calls.push({ tool: 'add_comment', args: { kind: 'status-justification' } });
+    }
+    else {
+        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
+    }
+    calls.push({ tool: 'update_task', args: { status: requested } });
+    return calls;
+}
+function simulateOptionalArtifactSave(workflowName, approveSave) {
+    const workflow = loadWorkflow(workflowName);
+    const artifact = Object.values(workflow.artifacts || {})[0];
+    const calls = [{ tool: 'render_in_screen' }];
+    if (!artifact || artifact.required || artifact.savePolicy !== 'ask-before-save') {
+        return calls;
+    }
+    calls.push({ tool: 'prompt_save_artifact', args: { path: artifact.path } });
+    if (approveSave) {
+        calls.push({ tool: 'write_file', args: { path: artifact.path } });
+        calls.push({ tool: 'attach_context_file', args: { path: artifact.path } });
+    }
+    return calls;
+}
+describe('Workflow simulation', () => {
+    it('/do routes by approach to execute when approach is implement', () => {
+        const result = simulateDoDispatch({ command: '/do', approach: 'implement', knownTaskId: true });
+        expect(result.routedTo).toBe('execute');
+        expect(result.calls[0].tool).toBe('get_task');
+    });
+    it('/do defaults to execute when approach is missing', () => {
+        const result = simulateDoDispatch({ command: '/do', knownTaskId: true });
+        expect(result.routedTo).toBe('execute');
+    });
+    it('explicit slash command wins over approach routing', () => {
+        const result = simulateDoDispatch({ command: '/review', approach: 'implement', knownTaskId: true });
+        expect(result.routedTo).toBe('review');
+    });
+    it('unknown task id uses list before get', () => {
+        const result = simulateDoDispatch({ command: '/do', approach: 'plan', knownTaskId: false });
+        expect(result.calls.map((c) => c.tool)).toEqual(['list_tasks', 'get_task']);
+    });
+    it('execute flow defaults to in-progress then review', () => {
+        const calls = simulateExecuteFlow({});
+        expect(calls.map((c) => c.tool)).toEqual(['update_task', 'add_comment', 'update_task']);
+        expect(calls[0].args?.status).toBe('in-progress');
+        expect(calls[2].args?.status).toBe('review');
+    });
+    it('execute flow requires justification for task/on-hold final status', () => {
+        const calls = simulateExecuteFlow({ explicitFinalStatus: 'on-hold' });
+        expect(calls[1].args?.kind).toBe('status-justification');
+        expect(calls[2].args?.status).toBe('on-hold');
+    });
+    it('execute flow blocks done/cancelled without explicit user instruction', () => {
+        expect(() => simulateExecuteFlow({ explicitFinalStatus: 'done' })).toThrow('Blocked unsafe status transition');
+    });
+    it('optional artifact flow prompts first and only attaches on approval', () => {
+        const noSave = simulateOptionalArtifactSave('evaluate', false);
+        expect(noSave.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact']);
+        const saved = simulateOptionalArtifactSave('evaluate', true);
+        expect(saved.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact', 'write_file', 'attach_context_file']);
+    });
+});

package/dist/services/workflowV2Policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{__tests__ → services}/workflowV2Policy.test.js

@@ -46,8 +46,8 @@ describe('Workflow v2 policy', () => {
         for (const { file, parsed } of docs) {
             expect(parsed.toolPolicy?.requiredToolsPolicy?.critical, `${file} critical policy`).toBe('strict-fail');
             expect(parsed.toolPolicy?.requiredToolsPolicy?.nonCritical, `${file} nonCritical policy`).toBe('warn-and-fallback');
-            expect(parsed.toolPolicy?.statusTransitions?.allowedStatuses).toEqual(expect.arrayContaining(['task', 'on-hold', 'in-progress', 'review']));
-            expect(parsed.toolPolicy?.statusTransitions?.forbiddenStatuses).toEqual(expect.arrayContaining(['done', 'cancelled']));
+            expect(parsed.toolPolicy?.statusTransitions?.allowedStatuses).toEqual(expect.arrayContaining(['task', 'on-hold', 'in-progress', 'review', 'done']));
+            expect(parsed.toolPolicy?.statusTransitions?.forbiddenStatuses).toEqual(expect.arrayContaining(['cancelled']));
         }
     });
     it('uses explicit MCP unavailable action', () => {

package/dist/shared/aiProfileSurfaceType.d.ts

@@ -0,0 +1,9 @@
+export declare const AI_PROFILE_SURFACE_TYPES: readonly ["chat_app", "ide", "coding_tool", "agent", "other"];
+export type AiProfileSurfaceType = typeof AI_PROFILE_SURFACE_TYPES[number];
+export type AiProfileSurfaceTypeSection = AiProfileSurfaceType | 'unclassified';
+export declare const AI_PROFILE_SURFACE_TYPE_SECTION_ORDER: AiProfileSurfaceTypeSection[];
+export declare function isAiProfileSurfaceType(value: unknown): value is AiProfileSurfaceType;
+export declare function parseAiProfileSurfaceType(value: unknown): AiProfileSurfaceType | null;
+export declare function formatAiProfileSurfaceTypeLabel(surfaceType: AiProfileSurfaceType): string;
+export declare function getAiProfileSurfaceTypeSection(surfaceType: AiProfileSurfaceType | null | undefined): AiProfileSurfaceTypeSection;
+export declare function formatAiProfileSurfaceTypeSectionLabel(section: AiProfileSurfaceTypeSection): string;

package/dist/shared/aiProfileSurfaceType.js

@@ -0,0 +1,49 @@
+export const AI_PROFILE_SURFACE_TYPES = [
+    'chat_app',
+    'ide',
+    'coding_tool',
+    'agent',
+    'other'
+];
+export const AI_PROFILE_SURFACE_TYPE_SECTION_ORDER = [
+    'chat_app',
+    'ide',
+    'coding_tool',
+    'agent',
+    'other',
+    'unclassified'
+];
+const AI_PROFILE_SURFACE_TYPE_LABELS = {
+    chat_app: 'Chat app',
+    ide: 'IDE',
+    coding_tool: 'Coding tool',
+    agent: 'Agent',
+    other: 'Other'
+};
+const AI_PROFILE_SURFACE_TYPE_SECTION_LABELS = {
+    chat_app: 'Chat Apps',
+    ide: 'IDEs',
+    coding_tool: 'Coding Tools',
+    agent: 'Agents',
+    other: 'Other',
+    unclassified: 'Unclassified'
+};
+export function isAiProfileSurfaceType(value) {
+    return typeof value === 'string'
+        && AI_PROFILE_SURFACE_TYPES.includes(value);
+}
+export function parseAiProfileSurfaceType(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return isAiProfileSurfaceType(normalized) ? normalized : null;
+}
+export function formatAiProfileSurfaceTypeLabel(surfaceType) {
+    return AI_PROFILE_SURFACE_TYPE_LABELS[surfaceType];
+}
+export function getAiProfileSurfaceTypeSection(surfaceType) {
+    return surfaceType ?? 'unclassified';
+}
+export function formatAiProfileSurfaceTypeSectionLabel(section) {
+    return AI_PROFILE_SURFACE_TYPE_SECTION_LABELS[section];
+}

package/dist/shared/customTaxonomyLibrary.d.ts

@@ -0,0 +1,11 @@
+import type { TaxonomyDefinition } from '../types';
+export interface CustomTaxonomyLibraryPack {
+    id: string;
+    label: string;
+    description: string;
+    domainTag?: string;
+    bestFor?: string;
+    taxonomies: TaxonomyDefinition[];
+}
+export declare function listBuiltInCustomTaxonomyLibraryPacks(): CustomTaxonomyLibraryPack[];
+export declare function getBuiltInCustomTaxonomyLibraryPack(packId: string): CustomTaxonomyLibraryPack | null;