@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/shared/agentRoleDefinition.js

@@ -0,0 +1,207 @@
+export const AGENT_ROLE_SCHEMA_VERSION = 1;
+const LIMITS = {
+    name: 80,
+    shortDescription: 240,
+    purpose: 2_000,
+    listItem: 1_000,
+    listItems: 24,
+    workingGuidance: 6_000,
+    reference: 200,
+    promptContent: 12_000,
+};
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function addIssue(issues, code, path, message) {
+    issues.push({ code, path, message });
+}
+function reportUnknownKeys(value, allowed, path, issues) {
+    const allowedKeys = new Set(allowed);
+    Object.keys(value).forEach((key) => {
+        if (allowedKeys.has(key))
+            return;
+        addIssue(issues, 'unknown_field', path ? `${path}.${key}` : key, 'This field is not part of Agent Role v1.');
+    });
+}
+function requiredString(value, path, maxLength, issues) {
+    if (typeof value !== 'string') {
+        addIssue(issues, 'required_string', path, 'A string value is required.');
+        return '';
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        addIssue(issues, 'required_string', path, 'A non-empty value is required.');
+    }
+    else if (normalized.length > maxLength) {
+        addIssue(issues, 'string_too_long', path, `Must be ${maxLength} characters or less.`);
+    }
+    return normalized;
+}
+function optionalString(value, path, maxLength, issues) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value !== 'string') {
+        addIssue(issues, 'invalid_string', path, 'Must be a string when provided.');
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (!normalized)
+        return undefined;
+    if (normalized.length > maxLength) {
+        addIssue(issues, 'string_too_long', path, `Must be ${maxLength} characters or less.`);
+    }
+    return normalized;
+}
+function stringList(value, path, options, issues) {
+    if (!Array.isArray(value)) {
+        addIssue(issues, 'invalid_list', path, 'Must be an array of strings.');
+        return [];
+    }
+    if (options.required && value.length === 0) {
+        addIssue(issues, 'required_list', path, 'Provide at least one item.');
+    }
+    if (options.maxItems && value.length > options.maxItems) {
+        addIssue(issues, 'too_many_items', path, `Provide no more than ${options.maxItems} items.`);
+    }
+    const seen = new Set();
+    const result = [];
+    value.forEach((entry, index) => {
+        if (typeof entry !== 'string') {
+            addIssue(issues, 'invalid_string', `${path}[${index}]`, 'Must be a string.');
+            return;
+        }
+        const normalized = entry.trim();
+        if (!normalized) {
+            addIssue(issues, 'empty_list_item', `${path}[${index}]`, 'List items cannot be blank.');
+            return;
+        }
+        if (normalized.length > options.maxItemLength) {
+            addIssue(issues, 'string_too_long', `${path}[${index}]`, `Must be ${options.maxItemLength} characters or less.`);
+        }
+        if (seen.has(normalized))
+            return;
+        seen.add(normalized);
+        result.push(normalized);
+    });
+    return result;
+}
+export function inspectAgentRoleDefinition(value) {
+    const issues = [];
+    if (!isPlainObject(value)) {
+        return {
+            definition: null,
+            issues: [{
+                    code: 'invalid_definition',
+                    path: '',
+                    message: 'Agent Role definition must be an object.',
+                }],
+        };
+    }
+    reportUnknownKeys(value, [
+        'schemaVersion',
+        'name',
+        'shortDescription',
+        'purpose',
+        'responsibilities',
+        'expectedOutputs',
+        'workingGuidance',
+        'recommendations',
+    ], '', issues);
+    if (value.schemaVersion !== AGENT_ROLE_SCHEMA_VERSION) {
+        addIssue(issues, 'unsupported_schema_version', 'schemaVersion', `Agent Role schemaVersion must be ${AGENT_ROLE_SCHEMA_VERSION}.`);
+    }
+    const name = requiredString(value.name, 'name', LIMITS.name, issues);
+    const shortDescription = requiredString(value.shortDescription, 'shortDescription', LIMITS.shortDescription, issues);
+    const purpose = requiredString(value.purpose, 'purpose', LIMITS.purpose, issues);
+    const responsibilities = stringList(value.responsibilities, 'responsibilities', {
+        required: true,
+        maxItems: LIMITS.listItems,
+        maxItemLength: LIMITS.listItem,
+    }, issues);
+    const expectedOutputs = stringList(value.expectedOutputs, 'expectedOutputs', {
+        required: true,
+        maxItems: LIMITS.listItems,
+        maxItemLength: LIMITS.listItem,
+    }, issues);
+    const workingGuidance = optionalString(value.workingGuidance, 'workingGuidance', LIMITS.workingGuidance, issues);
+    const recommendations = isPlainObject(value.recommendations)
+        ? value.recommendations
+        : null;
+    if (!recommendations) {
+        addIssue(issues, 'invalid_recommendations', 'recommendations', 'Recommendations must be an object.');
+    }
+    else {
+        reportUnknownKeys(recommendations, ['skillRefs', 'capabilityGroups'], 'recommendations', issues);
+    }
+    const skillRefs = stringList(recommendations?.skillRefs ?? [], 'recommendations.skillRefs', { maxItems: LIMITS.listItems, maxItemLength: LIMITS.reference }, issues);
+    const capabilityGroups = stringList(recommendations?.capabilityGroups ?? [], 'recommendations.capabilityGroups', { maxItems: LIMITS.listItems, maxItemLength: LIMITS.reference }, issues);
+    const definition = {
+        schemaVersion: AGENT_ROLE_SCHEMA_VERSION,
+        name,
+        shortDescription,
+        purpose,
+        responsibilities,
+        expectedOutputs,
+        ...(workingGuidance ? { workingGuidance } : {}),
+        recommendations: {
+            skillRefs,
+            capabilityGroups,
+        },
+    };
+    if (issues.length === 0 && compileNormalizedAgentRolePromptContent(definition).length > LIMITS.promptContent) {
+        addIssue(issues, 'compiled_prompt_too_long', '', `Compiled Role prompt content must be ${LIMITS.promptContent} characters or less.`);
+    }
+    return {
+        definition: issues.length === 0 ? definition : null,
+        issues,
+    };
+}
+export class AgentRoleDefinitionValidationError extends Error {
+    issues;
+    code = 'AGENT_ROLE_DEFINITION_INVALID';
+    statusCode = 400;
+    constructor(issues) {
+        super(issues[0]?.message || 'Agent Role definition is invalid.');
+        this.issues = issues;
+        this.name = 'AgentRoleDefinitionValidationError';
+    }
+}
+export function normalizeAgentRoleDefinition(value) {
+    const inspection = inspectAgentRoleDefinition(value);
+    if (!inspection.definition) {
+        throw new AgentRoleDefinitionValidationError(inspection.issues);
+    }
+    return inspection.definition;
+}
+export function serializeCanonicalAgentRoleDefinition(value) {
+    const normalize = (entry) => {
+        if (Array.isArray(entry))
+            return entry.map(normalize);
+        if (isPlainObject(entry)) {
+            return Object.fromEntries(Object.entries(entry)
+                .filter(([, item]) => item !== undefined)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, item]) => [key, normalize(item)]));
+        }
+        return entry;
+    };
+    return JSON.stringify(normalize(value));
+}
+function bullets(items) {
+    return items.map((item) => `- ${item}`).join('\n');
+}
+function compileNormalizedAgentRolePromptContent(definition) {
+    const sections = [
+        `Role: ${definition.name}`,
+        `Purpose and scope:\n${definition.purpose}`,
+        `Responsibilities:\n${bullets(definition.responsibilities)}`,
+        `Expected outputs:\n${bullets(definition.expectedOutputs)}`,
+        definition.workingGuidance
+            ? `Role-specific working guidance:\n${definition.workingGuidance}`
+            : '',
+    ].filter(Boolean);
+    return sections.join('\n\n');
+}
+export function compileAgentRolePromptContent(definition) {
+    return compileNormalizedAgentRolePromptContent(normalizeAgentRoleDefinition(definition));
+}

package/dist/shared/aiProfileAvatarEligibility.d.ts

@@ -0,0 +1,10 @@
+export interface AiProfileAvatarEligibilityInput {
+    surfaceType?: string | null;
+    archivedAt?: string | null;
+    mergedIntoProfileId?: string | null;
+    providerMetadata?: Record<string, unknown> | null;
+}
+export declare function getTaskforceManagedAgentId(profile: AiProfileAvatarEligibilityInput | null | undefined): string;
+export declare function isTaskforceManagedAiProfile(profile: AiProfileAvatarEligibilityInput): boolean;
+export declare const isTaskforceManagedAiProfileForAvatar: typeof isTaskforceManagedAiProfile;
+export declare function isAiProfileAvatarGenerationEligible(profile: AiProfileAvatarEligibilityInput | null | undefined): boolean;

package/dist/shared/aiProfileAvatarEligibility.js

@@ -0,0 +1,27 @@
+import { getMcpClientRegistryEntry } from '../mcp/clientRegistry.js';
+export function getTaskforceManagedAgentId(profile) {
+    const taskforce = profile?.providerMetadata?.taskforce;
+    if (!taskforce || typeof taskforce !== 'object' || Array.isArray(taskforce))
+        return '';
+    return String(taskforce.taskforceAgentId || '').trim();
+}
+export function isTaskforceManagedAiProfile(profile) {
+    return Boolean(getTaskforceManagedAgentId(profile));
+}
+export const isTaskforceManagedAiProfileForAvatar = isTaskforceManagedAiProfile;
+export function isAiProfileAvatarGenerationEligible(profile) {
+    if (!profile || profile.archivedAt || profile.mergedIntoProfileId || isTaskforceManagedAiProfile(profile))
+        return false;
+    if (profile.surfaceType !== 'agent')
+        return false;
+    const connection = profile.providerMetadata?.connection;
+    const clientId = connection && typeof connection === 'object' && !Array.isArray(connection)
+        ? connection.clientId
+        : null;
+    const client = getMcpClientRegistryEntry(clientId);
+    if (client?.logoKey)
+        return false;
+    if (client?.surfaceHint && client.surfaceHint !== 'agent')
+        return false;
+    return true;
+}

package/dist/shared/aiProfileColors.d.ts

@@ -0,0 +1,7 @@
+export declare const AI_PROFILE_GENERIC_GRAY = "#6b7280";
+export declare const AI_PROFILE_COLOR_TOKENS: readonly ["red-500", "orange-500", "amber-500", "green-700", "teal-700", "sky-500", "sky-700", "blue-500", "indigo-700", "violet-500"];
+export declare const AI_PROFILE_COLOR_SOURCES: readonly ["user_override", "agent_explicit", "product_default", "assigned_default", "legacy"];
+export type AiProfileColorSource = typeof AI_PROFILE_COLOR_SOURCES[number];
+export declare function normalizeAiProfileColor(value: unknown): string | null;
+export declare function parseAiProfileColorSource(value: unknown): AiProfileColorSource | null;
+export declare function assignedAiProfileColor(stableIdentity: string): string;

package/dist/shared/aiProfileColors.js

@@ -0,0 +1,33 @@
+import { COLOR_PALETTE, resolveColor } from './colorPalette.js';
+export const AI_PROFILE_GENERIC_GRAY = '#6b7280';
+export const AI_PROFILE_COLOR_TOKENS = [
+    'red-500', 'orange-500', 'amber-500', 'green-700', 'teal-700',
+    'sky-500', 'sky-700', 'blue-500', 'indigo-700', 'violet-500',
+];
+export const AI_PROFILE_COLOR_SOURCES = ['user_override', 'agent_explicit', 'product_default', 'assigned_default', 'legacy'];
+export function normalizeAiProfileColor(value) {
+    const raw = String(value || '').trim().toLowerCase();
+    const resolved = resolveColor(raw);
+    if (!resolved)
+        return null;
+    const short = /^#([0-9a-f]{3})$/i.exec(resolved);
+    if (short)
+        return `#${short[1].split('').map((part) => part + part).join('')}`.toLowerCase();
+    return /^#[0-9a-f]{6}$/i.test(resolved) ? resolved.toLowerCase() : null;
+}
+export function parseAiProfileColorSource(value) {
+    const normalized = String(value || '').trim();
+    return AI_PROFILE_COLOR_SOURCES.includes(normalized)
+        ? normalized
+        : null;
+}
+export function assignedAiProfileColor(stableIdentity) {
+    const identity = String(stableIdentity || 'ai').trim().toLowerCase();
+    let hash = 2166136261;
+    for (let index = 0; index < identity.length; index += 1) {
+        hash ^= identity.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    const token = AI_PROFILE_COLOR_TOKENS[(hash >>> 0) % AI_PROFILE_COLOR_TOKENS.length];
+    return COLOR_PALETTE[token].toLowerCase();
+}

package/dist/shared/colorPalette.d.ts

@@ -0,0 +1,3 @@
+export declare const COLOR_PALETTE: Record<string, string>;
+export declare const PALETTE_ORDER: string[];
+export declare function resolveColor(colorValue?: string): string | undefined;

package/dist/shared/colorPalette.js

@@ -0,0 +1,20 @@
+export const COLOR_PALETTE = {
+    'red-200': '#eb7a7a', 'orange-200': '#eba87a', 'amber-200': '#ebc17a', 'yellow-200': '#ebd07a',
+    'green-200': '#7aeba4', 'teal-200': '#7aebdf', 'sky-200': '#7ac8eb', 'blue-200': '#7aa5eb',
+    'indigo-200': '#7a7ceb', 'violet-200': '#9c7aeb', 'red-500': '#e42525', 'orange-500': '#e47325',
+    'amber-500': '#e49d25', 'yellow-500': '#e4b625', 'green-500': '#25e46b', 'teal-500': '#25e4cf',
+    'sky-500': '#25a9e4', 'blue-500': '#256ee4', 'indigo-500': '#2529e4', 'violet-500': '#5f25e4',
+    'red-700': '#951818', 'orange-700': '#954b18', 'amber-700': '#956718', 'yellow-700': '#957718',
+    'green-700': '#189546', 'teal-700': '#189587', 'sky-700': '#186e95', 'blue-700': '#184895',
+    'indigo-700': '#181b95', 'violet-700': '#3e1895',
+};
+export const PALETTE_ORDER = [
+    'red-200', 'orange-200', 'amber-200', 'yellow-200', 'green-200', 'teal-200', 'sky-200', 'blue-200', 'indigo-200', 'violet-200',
+    'red-500', 'orange-500', 'amber-500', 'yellow-500', 'green-500', 'teal-500', 'sky-500', 'blue-500', 'indigo-500', 'violet-500',
+    'red-700', 'orange-700', 'amber-700', 'yellow-700', 'green-700', 'teal-700', 'sky-700', 'blue-700', 'indigo-700', 'violet-700',
+];
+export function resolveColor(colorValue) {
+    if (!colorValue)
+        return undefined;
+    return COLOR_PALETTE[colorValue] || colorValue;
+}

package/dist/shared/commentProvenance.d.ts

@@ -0,0 +1,4 @@
+export declare const UNVERIFIED_COMMENT_IMPORT_ACTOR = "system:unverified-comment-import";
+export declare const UNVERIFIED_COMMENT_IMPORT_LABEL = "Imported comment";
+export declare const UNVERIFIED_COMMENT_IMPORT_DESCRIPTION = "This comment was recovered during synchronization, but its author could not be verified.";
+export declare function isUnverifiedCommentImportActor(actorRef: unknown): boolean;

package/dist/shared/commentProvenance.js

@@ -0,0 +1,6 @@
+export const UNVERIFIED_COMMENT_IMPORT_ACTOR = 'system:unverified-comment-import';
+export const UNVERIFIED_COMMENT_IMPORT_LABEL = 'Imported comment';
+export const UNVERIFIED_COMMENT_IMPORT_DESCRIPTION = 'This comment was recovered during synchronization, but its author could not be verified.';
+export function isUnverifiedCommentImportActor(actorRef) {
+    return String(actorRef || '').trim().toLowerCase() === UNVERIFIED_COMMENT_IMPORT_ACTOR;
+}

package/dist/shared/deletedTaskRetention.d.ts

@@ -0,0 +1,2 @@
+export declare const DELETED_TASK_RETENTION_DAYS = 90;
+export declare function getDeletedTaskExpiresAt(deletedAt: unknown): string | null;

package/dist/shared/deletedTaskRetention.js

@@ -0,0 +1,7 @@
+export const DELETED_TASK_RETENTION_DAYS = 90;
+export function getDeletedTaskExpiresAt(deletedAt) {
+    const deletedAtMs = Date.parse(String(deletedAt || '').trim());
+    if (!Number.isFinite(deletedAtMs))
+        return null;
+    return new Date(deletedAtMs + (DELETED_TASK_RETENTION_DAYS * 24 * 60 * 60 * 1000)).toISOString();
+}

package/dist/shared/passwordPolicy.d.ts

@@ -1,5 +1,6 @@
 export declare const MIN_PASSWORD_LENGTH = 12;
-export type PasswordPolicyCode = 'PASSWORD_REQUIRED' | 'PASSWORD_TOO_SHORT' | 'PASSWORD_TOO_COMMON' | 'PASSWORD_CONTAINS_PERSONAL_INFO';
+export declare const MAX_PASSWORD_LENGTH = 256;
+export type PasswordPolicyCode = 'PASSWORD_REQUIRED' | 'PASSWORD_TOO_SHORT' | 'PASSWORD_TOO_LONG' | 'PASSWORD_TOO_COMMON' | 'PASSWORD_CONTAINS_PERSONAL_INFO';
 export interface PasswordPolicyResult {
     ok: boolean;
     code?: PasswordPolicyCode;

package/dist/shared/passwordPolicy.js

@@ -1,4 +1,5 @@
 export const MIN_PASSWORD_LENGTH = 12;
+export const MAX_PASSWORD_LENGTH = 256;
 const COMMON_PASSWORDS = new Set([
     '12345678',
     '123456789',
@@ -44,6 +45,7 @@ function extractPersonalInfoTokens(context) {
 export function getPasswordPolicyGuidance() {
     return [
         `Use at least ${MIN_PASSWORD_LENGTH} characters.`,
+        `Use no more than ${MAX_PASSWORD_LENGTH} characters.`,
         'Avoid common passwords or obvious patterns.',
         'Do not include your email or display name.'
     ];
@@ -64,6 +66,13 @@ export function validatePasswordPolicy(password, context) {
             message: `Password must be at least ${MIN_PASSWORD_LENGTH} characters.`
         };
     }
+    if (rawPassword.length > MAX_PASSWORD_LENGTH) {
+        return {
+            ok: false,
+            code: 'PASSWORD_TOO_LONG',
+            message: `Password must be no more than ${MAX_PASSWORD_LENGTH} characters.`
+        };
+    }
     const normalizedPassword = normalizeForComparison(rawPassword);
     if (COMMON_PASSWORDS.has(normalizedPassword)) {
         return {

package/dist/shared/planningIdentity.d.ts

@@ -0,0 +1,20 @@
+export type PlanningIdentityEntityType = 'initiative' | 'workstream';
+export declare const PLANNING_IDENTITY_ICONS: readonly ["Target", "Route", "Flag", "Rocket", "Briefcase", "Folder", "Layers", "Map", "Compass", "Landmark", "BookOpen", "Lightbulb", "Wrench", "Shield", "Bug", "Palette", "Camera", "Music", "Heart", "Globe", "Users", "Sparkles", "FlaskConical", "Code"];
+export type PlanningIdentityIcon = typeof PLANNING_IDENTITY_ICONS[number];
+export declare const PLANNING_IDENTITY_COLORS: readonly ["red", "orange", "amber", "green", "teal", "sky", "blue", "indigo", "violet"];
+export type PlanningIdentityColor = typeof PLANNING_IDENTITY_COLORS[number];
+export declare function normalizePlanningIdentityIcon(value: unknown): PlanningIdentityIcon | null;
+export declare function normalizePlanningIdentityColor(value: unknown): PlanningIdentityColor | null;
+export declare function assertPlanningIdentityIcon(value: unknown): PlanningIdentityIcon | null;
+export declare function assertPlanningIdentityColor(value: unknown): PlanningIdentityColor | null;
+export declare function resolvePlanningIdentity(input: {
+    entityType: PlanningIdentityEntityType;
+    entityId: string;
+    icon?: unknown;
+    color?: unknown;
+}): {
+    icon: PlanningIdentityIcon;
+    color: PlanningIdentityColor | null;
+    customized: boolean;
+};
+export declare function planningIdentityColorToken(color?: PlanningIdentityColor | null): string;

package/dist/shared/planningIdentity.js

@@ -0,0 +1,79 @@
+export const PLANNING_IDENTITY_ICONS = Object.freeze([
+    'Target',
+    'Route',
+    'Flag',
+    'Rocket',
+    'Briefcase',
+    'Folder',
+    'Layers',
+    'Map',
+    'Compass',
+    'Landmark',
+    'BookOpen',
+    'Lightbulb',
+    'Wrench',
+    'Shield',
+    'Bug',
+    'Palette',
+    'Camera',
+    'Music',
+    'Heart',
+    'Globe',
+    'Users',
+    'Sparkles',
+    'FlaskConical',
+    'Code',
+]);
+export const PLANNING_IDENTITY_COLORS = Object.freeze([
+    'red',
+    'orange',
+    'amber',
+    'green',
+    'teal',
+    'sky',
+    'blue',
+    'indigo',
+    'violet',
+]);
+const ICON_SET = new Set(PLANNING_IDENTITY_ICONS);
+const COLOR_SET = new Set(PLANNING_IDENTITY_COLORS);
+export function normalizePlanningIdentityIcon(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return ICON_SET.has(normalized) ? normalized : null;
+}
+export function normalizePlanningIdentityColor(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return COLOR_SET.has(normalized) ? normalized : null;
+}
+export function assertPlanningIdentityIcon(value) {
+    const normalized = normalizePlanningIdentityIcon(value);
+    if (value !== null && value !== undefined && value !== '' && !normalized) {
+        throw new Error('Planning identity icon is not supported.');
+    }
+    return normalized;
+}
+export function assertPlanningIdentityColor(value) {
+    const normalized = normalizePlanningIdentityColor(value);
+    if (value !== null && value !== undefined && value !== '' && !normalized) {
+        throw new Error('Planning identity color is not supported.');
+    }
+    return normalized;
+}
+export function resolvePlanningIdentity(input) {
+    const explicitIcon = normalizePlanningIdentityIcon(input.icon);
+    const explicitColor = normalizePlanningIdentityColor(input.color);
+    return {
+        icon: explicitIcon || (input.entityType === 'initiative' ? 'Target' : 'Route'),
+        color: explicitColor,
+        customized: Boolean(explicitIcon || explicitColor),
+    };
+}
+export function planningIdentityColorToken(color) {
+    return color
+        ? `var(--planning-identity-${color})`
+        : 'var(--planning-progress-empty)';
+}

package/dist/shared/taskDeepLinks.d.ts

@@ -0,0 +1,28 @@
+export declare const TASK_DEEP_LINK_QUERY_KEYS: {
+    readonly workspaceId: "workspaceId";
+    readonly task: "task";
+    readonly activity: "activity";
+    readonly comment: "comment";
+    readonly initiative: "initiative";
+    readonly workstream: "workstream";
+    readonly image: "image";
+    readonly document: "document";
+};
+type DeepLinkTarget = 'task' | 'initiative' | 'workstream' | 'image' | 'document';
+export interface BuildTaskDeepLinkInput {
+    applicationBaseUrl: string | null | undefined;
+    workspaceId: string;
+    taskId: string;
+    activityId?: string | null;
+}
+export interface BuildTaskforceDeepLinkInput {
+    applicationBaseUrl: string | null | undefined;
+    workspaceId: string;
+    target: DeepLinkTarget;
+    id: string;
+    activityId?: string | null;
+}
+export declare function normalizeTaskforceApplicationBaseUrl(value: string | null | undefined): string | null;
+export declare function buildTaskDeepLink(input: BuildTaskDeepLinkInput): string | null;
+export declare function buildTaskforceDeepLink(input: BuildTaskforceDeepLinkInput): string | null;
+export {};

package/dist/shared/taskDeepLinks.js

@@ -0,0 +1,48 @@
+export const TASK_DEEP_LINK_QUERY_KEYS = {
+    workspaceId: 'workspaceId',
+    task: 'task',
+    activity: 'activity',
+    comment: 'comment',
+    initiative: 'initiative',
+    workstream: 'workstream',
+    image: 'image',
+    document: 'document',
+};
+export function normalizeTaskforceApplicationBaseUrl(value) {
+    const candidate = String(value || '').trim();
+    if (!candidate)
+        return null;
+    try {
+        const url = new URL(candidate);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        return url.origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildTaskDeepLink(input) {
+    return buildTaskforceDeepLink({
+        applicationBaseUrl: input.applicationBaseUrl,
+        workspaceId: input.workspaceId,
+        target: 'task',
+        id: input.taskId,
+        activityId: input.activityId,
+    });
+}
+export function buildTaskforceDeepLink(input) {
+    const applicationBaseUrl = normalizeTaskforceApplicationBaseUrl(input.applicationBaseUrl);
+    const workspaceId = String(input.workspaceId || '').trim();
+    const id = String(input.id || '').trim();
+    if (!applicationBaseUrl || !workspaceId || !id)
+        return null;
+    const url = new URL('/', applicationBaseUrl);
+    url.searchParams.set(TASK_DEEP_LINK_QUERY_KEYS.workspaceId, workspaceId);
+    url.searchParams.set(TASK_DEEP_LINK_QUERY_KEYS[input.target], id);
+    const activityId = String(input.activityId || '').trim();
+    if (input.target === 'task' && activityId) {
+        url.searchParams.set(TASK_DEEP_LINK_QUERY_KEYS.activity, activityId);
+    }
+    return url.toString();
+}

package/dist/shared/taskRestoreDestination.d.ts

@@ -0,0 +1,2 @@
+export type TaskRestoreDestination = 'previous' | 'archive';
+export declare function parseTaskRestoreDestination(value: unknown): TaskRestoreDestination | null;

package/dist/shared/taskRestoreDestination.js

@@ -0,0 +1,5 @@
+export function parseTaskRestoreDestination(value) {
+    if (value === undefined)
+        return 'previous';
+    return value === 'previous' || value === 'archive' ? value : null;
+}

package/dist/shared/taskforceAgentDefinition.d.ts

@@ -0,0 +1,88 @@
+import { type TaskforceAgentConnectionScope, type TaskforceAgentModelSource, type TaskforceAgentProviderKey } from './taskforceAgentModels.js';
+import type { ModelGatewayTier } from '../services/modelGateway';
+export declare const AGENT_DEFINITION_SCHEMA_VERSION: 1;
+export type AgentLifecycleStatus = 'active' | 'disabled' | 'retired';
+export type AgentConfigurationState = 'valid' | 'unresolved-references' | 'needs-migration' | 'unsupported-version' | 'invalid';
+export interface AgentConfigurationIssue {
+    code: string;
+    path?: string;
+    message: string;
+}
+export interface AgentModelSelection {
+    providerKey: TaskforceAgentProviderKey;
+    modelKey: string;
+    modelSource: TaskforceAgentModelSource;
+    tier: ModelGatewayTier;
+    connectionScope?: TaskforceAgentConnectionScope;
+    connectionId?: string | null;
+}
+export interface AgentBehaviorConfig {
+    personality?: {
+        presetKey?: string;
+        customDescription?: string;
+    };
+    responseStyle?: {
+        presetKey?: string;
+        customDescription?: string;
+    };
+    workingGuidelines?: string;
+}
+export type AvatarArtStyle = {
+    mode: 'preset';
+    presetKey: string;
+} | {
+    mode: 'custom';
+    customDescription: string;
+};
+export interface BehaviorReference {
+    id: string;
+    resolution: 'current' | 'pinned';
+    revision?: number | string;
+}
+export interface CurrentPolicyReference {
+    id: string;
+    resolution: 'current';
+}
+export interface AgentToolPolicy {
+    basePolicyRef: CurrentPolicyReference;
+    requestedCapabilities?: string[];
+    disabledCapabilities?: string[];
+    toolOverrides?: Array<{
+        toolName: string;
+        enabled: boolean;
+    }>;
+}
+export interface AgentDefinitionV1 {
+    schemaVersion: typeof AGENT_DEFINITION_SCHEMA_VERSION;
+    name: string;
+    purpose: string;
+    model: AgentModelSelection;
+    behavior: AgentBehaviorConfig;
+    presentation: {
+        avatar: {
+            visualDescription?: string;
+            artStyle?: AvatarArtStyle;
+        };
+    };
+    roleRef?: BehaviorReference;
+    skillRefs: BehaviorReference[];
+    memoryPolicyRef?: CurrentPolicyReference;
+    toolPolicy: AgentToolPolicy;
+}
+export interface AgentDefinitionInspection {
+    state: AgentConfigurationState;
+    issues: AgentConfigurationIssue[];
+    definition: AgentDefinitionV1 | null;
+    opaqueDefinition?: unknown;
+}
+export interface AgentPromptProjection {
+    name: string;
+    purpose: string;
+    behavior: AgentBehaviorConfig;
+}
+export declare function inspectAgentDefinition(value: unknown): AgentDefinitionInspection;
+export declare function requireValidAgentDefinition(value: unknown): AgentDefinitionV1;
+export declare function serializeCanonicalJson(value: unknown): string;
+export declare function serializeCanonicalAgentDefinition(definition: AgentDefinitionV1): string;
+export declare function hashAgentDefinition(definition: AgentDefinitionV1): Promise<string>;
+export declare function projectAgentDefinitionForPrompt(definition: AgentDefinitionV1): AgentPromptProjection;