@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.1

package/dist/sdk/src/types.d.ts

@@ -0,0 +1,492 @@
+import type { BuiltinSelection, BuiltinSnapshot, CapabilityDescriptor } from '../../shared/agent-capabilities.js';
+import type { AuthSession, AuthPasswordChangeRequired } from '../../shared/desktop-api.js';
+import type { CredentialProvider, ManagedAuthentication } from '../../shared/managed-authorization.js';
+export type { TeamState, TeamMemberState, TeamTaskState, TeamCommand, TeamCommandResult } from '../../shared/team-control.js';
+export type { ManagedAuthentication, ManagedPrincipal, ManagedCredential, ManagedCredentialRequest, CredentialProvider, CredentialReason, ManagedAuthorizationEvent } from '../../shared/managed-authorization.js';
+export type { BuiltinSelection, BuiltinSnapshot, CapabilityDescriptor, ToolCategory, SkillCategory } from '../../shared/agent-capabilities.js';
+export type { AuthSession, PlatformUser, TenantSummary, LoginContext, AuthRequiredPasswordChangeRequest, AuthSwitchSubjectRequest } from '../../shared/desktop-api.js';
+export type { AvailableChatModel } from '../../shared/cloud-assistant-api.js';
+export type { AccountContextSummary, AccountContextQuery } from '../../shared/account-context-api.js';
+export type { PersonalUsageStatistics } from '../../shared/usage-statistics-api.js';
+export type { EnterpriseKnowledgeBase, EnterpriseKnowledgeSearchQuery, EnterpriseKnowledgeSearchResult, EnterpriseKnowledgeDocument, EnterpriseKnowledgeTreeResult } from '../../shared/enterprise-knowledge-api.js';
+export type { SkillMarketItem, SkillMarketDetail, SkillMarketSearchQuery, SkillMarketSearchResult } from '../../shared/skill-market-api.js';
+export type { PluginMarketItem, PluginMarketDetail, PluginMarketListQuery, PluginMarketListResult } from '../../shared/plugin-market-api.js';
+export type { PluginAuthorizationStatus, PluginAuthorizationDefinition, PluginAuthorizationSaveRequest } from '../../shared/plugin-market-api.js';
+export type { LocalPluginInstallation } from '../../shared/local-plugin-api.js';
+export type { SkillVersionSelection, SkillVersionUpdate } from '../../core/skills/skill-versions.js';
+export interface SkillVersionInfo {
+    binding: import('../../core/skills/skill-bindings.js').SkillBinding;
+    current: import('../../shared/local-task-api.js').LocalTaskSkillReference;
+}
+export type SkillVersionUpdateResult = Awaited<ReturnType<typeof import('../../core/skills/skill-versions.js').updateSkillVersion>>;
+export interface PluginUpdateResult {
+    changed: boolean;
+    before: {
+        recordId: string;
+        version?: string | null;
+    };
+    installation: import('../../shared/local-plugin-api.js').LocalPluginInstallation;
+}
+export interface ExternalModel {
+    generationCapabilities?: import('../../shared/runtime-tuning.js').GenerationCapabilities;
+    id: string;
+    endpoint: string;
+    model: string;
+    protocol: 'chat_completions' | 'responses';
+    apiKey?: string;
+    contextWindow: number;
+    maxOutputTokens?: number;
+    functionCalling: boolean;
+    imageInput?: boolean;
+    reasoning?: boolean;
+}
+export interface RuntimeOptions {
+    /** Omit to use the matching runtime installed with this npm package. */
+    directory?: string;
+    dataDirectory: string;
+    /** Optional storage bases. Each uses the same app/principal partition as dataDirectory. */
+    workspaceDirectory?: string;
+    cacheDirectory?: string;
+    temporaryDirectory?: string;
+    nodeExecutable?: string;
+    tools?: Partial<Record<'node' | 'python' | 'git' | 'bash' | 'npm', string>>;
+    chromiumExecutable?: string;
+    /** Override only for a runtime built and signed by your own organization. */
+    trustedPublicKey?: string;
+}
+/** Attach to an already running CLI; never starts, installs or stops that service. */
+export interface CliConnectionOptions {
+    dataDirectory: string;
+    appId: string;
+    userScope: string;
+    appName?: string;
+    builtins?: BuiltinSelection;
+}
+export interface NetworkOptions {
+    proxyMode: 'off' | 'system' | 'custom';
+    proxyUrl: string;
+    caFile: string;
+    noProxy: string;
+}
+interface CommonOptions {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    /** Explicit host declarations, keyed by platform model code. Unlisted parameters are rejected. */
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    appId: string;
+    userScope: string;
+    appName?: string;
+    runtime: RuntimeOptions;
+    builtins?: BuiltinSelection;
+    network?: NetworkOptions;
+    communication?: import('./communication.js').CommunicationOptions;
+}
+export type ClientOptions = CommonOptions & ({
+    mode: 'platform';
+    platformBaseUrl: string;
+    environment?: 'dev' | 'prod';
+    /** Omit for SDK-managed interactive login. Managed mode never stores platform credentials. */
+    authentication?: ManagedAuthentication;
+} | {
+    mode: 'standalone';
+    models: ExternalModel[];
+});
+export type ResolvedClientOptions = ClientOptions & {
+    runtime: RuntimeOptions & {
+        directory: string;
+    };
+};
+export interface ClientServices {
+    credentials?: CredentialProvider;
+    diagnostics?: import('./diagnostics.js').DiagnosticSink;
+    memoryStore?: import('../../shared/memory-customization.js').MemoryStoreAdapter;
+    authorize?: import('./authorization.js').SessionAuthorizer;
+}
+export interface ToolContext {
+    files?: {
+        resolve(path: string, access: 'read' | 'write'): Promise<import('./file-storage.js').FileReference>;
+    };
+    signal: AbortSignal;
+    callId: string;
+    /** Present on calls dispatched by the SDK execution engine; not model arguments. */
+    execution?: Readonly<import('../../shared/execution-context.js').ExecutionBinding & {
+        invocationId: string;
+    }>;
+}
+export interface BusinessTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    readOnly: boolean;
+    execute(input: Record<string, unknown>, context: ToolContext): unknown | Promise<unknown>;
+}
+export interface McpServer {
+    id: string;
+    name: string;
+    transport: 'HTTP' | 'STDIO';
+    url?: string;
+    bearerToken?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    tools?: string[];
+    defaultToolsApproval?: 'auto' | 'prompt';
+    toolApprovals?: Record<string, 'auto' | 'prompt'>;
+}
+export interface ExecutionDefaults {
+    runtimeTuning?: import('../../shared/runtime-tuning.js').RuntimeTuning;
+    model: string;
+    mode?: 'agent' | 'plan' | 'chat';
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    thinkingEnabled?: boolean;
+    reasoningEffort?: import('../../shared/model-selection.js').ModelReasoningEffort;
+    /** Requested window; the shared model policy validates it against the model capacity. */
+    contextWindow?: number;
+}
+export interface AgentDefinition extends ExecutionDefaults {
+    jsHooks?: Partial<Record<'beforeTool' | 'afterTool', {
+        matcher?: string;
+        timeoutMs?: number;
+        execute(event: Readonly<import('../../shared/js-agent-hooks.js').ToolLifecycleEvent>, context: {
+            signal: AbortSignal;
+        }): void | import('../../shared/js-agent-hooks.js').ToolHookDecision | Promise<void | import('../../shared/js-agent-hooks.js').ToolHookDecision>;
+    }>>;
+    /** Serializable lifecycle policy returned by session configuration. */
+    jsHookDefinitions?: import('../../shared/js-agent-hooks.js').JsHookDefinition[];
+    team?: import('../../shared/agent-team.js').AgentTeamDefinition;
+    id: string;
+    version: string;
+    name: string;
+    instructions: string;
+    rules?: import('../../shared/session-policy.js').ApplicationRule[];
+    profile?: import('../../shared/execution-profile.js').ExecutionProfile;
+    hooks?: import('../../shared/agent-hooks.js').AgentCommandHook[];
+    builtins?: BuiltinSelection;
+    tools?: BusinessTool[];
+    /** Stable logical identity, independent of the callback URL and secret. */
+    toolProviderId?: string;
+    mcpServers?: McpServer[];
+    skills?: import('../../shared/local-task-api.js').LocalTaskSkillReference[];
+    plugins?: import('../../shared/local-task-api.js').LocalTaskPluginReference[];
+}
+export type { LocalSkillDefinition } from '../../shared/local-skill-api.js';
+export type { ExecutionProfile } from '../../shared/execution-profile.js';
+export type { AgentCommandHook } from '../../shared/agent-hooks.js';
+export type { AgentTeamDefinition, AgentTeamMember } from '../../shared/agent-team.js';
+export type { TaskPathPolicy } from '../../shared/task-path-policy.js';
+export type { TaskOperationReference, TaskOperationSnapshot } from '../../shared/task-operation.js';
+export type { ExecutionContext, ExecutionBinding } from '../../shared/execution-context.js';
+export type { SessionScopePolicy, SessionMemoryPolicy, RunMemoryPolicy, ApplicationRule } from '../../shared/session-policy.js';
+export interface SessionCreateOptions {
+    name?: string;
+    workspacePath?: string;
+    creationId?: string;
+    policy?: import('../../shared/session-policy.js').SessionScopePolicy;
+}
+export type { ArtifactEvidence, ArtifactVerification } from '../../shared/artifact-evidence.js';
+export interface ArtifactQuery {
+    runId?: string;
+    query?: string;
+    type?: import('../../shared/local-task-api.js').LocalTaskArtifactType;
+    limit?: number;
+}
+export type SessionArtifact = import('../../shared/local-task-api.js').LocalTaskArtifact & {
+    /** Latest observed reference, or workspace-only when no execution evidence exists. */
+    source: {
+        kind: 'execution' | 'workspace';
+        eventId?: string;
+        runId?: string;
+        threadId?: string;
+        tool?: string;
+        at?: string;
+    };
+    evidence: import('../../shared/artifact-evidence.js').ArtifactEvidence[];
+    operations: import('../../shared/task-operation.js').TaskOperationReference[];
+};
+export interface SessionInfo {
+    id: string;
+    name: string;
+    workspacePath: string;
+    status: string;
+    metadataRevision: string;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string;
+}
+export interface SessionConfiguration {
+    revision: number;
+    agent: Omit<AgentDefinition, 'tools' | 'mcpServers' | 'jsHooks'>;
+    builtins: BuiltinSnapshot;
+    defaults: ExecutionDefaults;
+    policy?: import('../../shared/session-policy.js').SessionScopePolicy;
+    parent?: {
+        sessionId: string;
+        memberId: string;
+        configurationRevision: number;
+    };
+}
+export interface SessionAgentUpdate {
+    agentId: string;
+    agentVersion: string;
+    expectedRevision: number;
+}
+export interface ProviderStatus {
+    agentId: string;
+    agentVersion: string;
+    /** Registration status only; does not assert that an external MCP server is reachable. */
+    status: 'registered' | 'unregistered';
+    providers: Array<{
+        id: string;
+        name: string;
+    }>;
+    ownedByCaller: boolean;
+}
+export interface ConfigurationUpdate {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    communication?: import('./communication.js').CommunicationOptions;
+    runtime?: RuntimeOptions;
+    builtins?: BuiltinSelection;
+    network?: NetworkOptions;
+    platformBaseUrl?: string;
+    models?: ExternalModel[];
+}
+export interface ClientConfiguration {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    communication?: import('./communication.js').CommunicationOptions;
+    mode: ClientOptions['mode'];
+    appId: string;
+    userScope: string;
+    appName: string;
+    runtime: RuntimeOptions;
+    paths: {
+        contextDirectory: string;
+        resourcesDirectory: string;
+        tasksDirectory: string;
+        workspacesDirectory: string;
+        temporaryDirectory: string;
+        cacheDirectory: string;
+    };
+    builtins: BuiltinSnapshot;
+    network: NetworkOptions;
+    platformBaseUrl?: string;
+    models?: Array<Omit<ExternalModel, 'apiKey'> & {
+        apiKeyConfigured: boolean;
+    }>;
+    authentication?: ManagedAuthentication;
+}
+export type DependencyStatus = import('../../core/host/runtime-dependencies.js').ResolvedRuntimeDependencies;
+export type LocalPreferences = import('../../cli/daemon/preferences.js').Preferences;
+export type LocalPreferenceDomain = import('../../cli/daemon/preferences.js').PreferenceDomain | 'securityPolicy';
+export type { ComputerUseSettings } from '../../shared/computer-use-api.js';
+export type { NativeSettings, NativeCapabilityStatus } from './native-status.js';
+export type { MemoryView, MemoryEditRequest } from '../../shared/local-memory.js';
+export interface TaskEvent {
+    schemaVersion: 1;
+    /** Save after processing this event to resume without skipping the rest of its page. */
+    cursor: string;
+    sessionId: string;
+    id: string;
+    type: import('../../shared/local-task-api.js').LocalTaskEventType;
+    runId: string;
+    /** Sequence within this cursor stream; use the event ID for deduplication. */
+    sequence: number;
+    runtimeSequence?: number;
+    /** Original engine event kind; payload retains its full structured fields. */
+    runtimeType?: string;
+    threadId?: string;
+    turnId?: string;
+    itemId?: string;
+    requestId?: string;
+    rootThreadId?: string;
+    sourceThreadId?: string;
+    parentThreadId?: string;
+    /** Host-supplied business ownership; separate from local task/member/thread identifiers. */
+    context?: import('../../shared/execution-context.js').ExecutionContext;
+    payload: Record<string, unknown>;
+    createdAt?: string;
+}
+/** Includes session-level events without a run and late updates after a run completes. */
+export type SessionEvent = Omit<TaskEvent, 'runId'> & {
+    runId?: string;
+};
+export interface SessionEventPage {
+    events: SessionEvent[];
+    cursor: string;
+}
+export interface EventObservationOptions {
+    cursor?: string;
+    signal?: AbortSignal;
+}
+export interface SessionMemoryApi {
+    get(request: import('../../shared/local-memory.js').MemoryContextRequest & {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    edit(request: import('../../shared/local-memory.js').MemoryEditRequest & {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    reset(request: {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    setEnabled(request: {
+        sessionId: string;
+        enabled: boolean;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+}
+export interface TaskInteraction {
+    id: string;
+    kind: string;
+    requestId: string;
+    runId: string;
+    status: string;
+    payload: Record<string, unknown>;
+}
+/** Same history contract consumed by the desktop renderer, including references, reasoning and usage. */
+export type TaskMessage = import('../../shared/local-task-api.js').LocalTaskMessage;
+export interface HistoryQuery {
+    text?: string;
+    around?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface HistoryPage {
+    items: TaskMessage[];
+    historyVersion: string;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+export interface RunQuery {
+    cursor?: string;
+    limit?: number;
+}
+export interface RunRecord {
+    runId: string;
+    status: RunState['status'];
+    messageCount: number;
+    /** Journal timestamps; these do not claim the time a model request began. */
+    firstMessageAt?: string;
+    queuedAt?: string;
+    finishedAt?: string;
+    context?: import('../../shared/execution-context.js').ExecutionContext;
+}
+export interface RunPage {
+    items: RunRecord[];
+    revision: string;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+export interface RunState {
+    status: 'queued' | 'running' | 'waiting' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    runId: string;
+    interactions: TaskInteraction[];
+    messages: TaskMessage[];
+}
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: string;
+    platformBaseUrl: string;
+}
+export type CredentialStoreOptions = {
+    kind: 'session' | 'system';
+} | {
+    kind: 'vault';
+    secret: string;
+};
+export type LoginRequest = {
+    loginType: 'USERNAME' | 'PHONE';
+    account: string;
+    password: string;
+    countryCode?: string;
+    credentialStore?: CredentialStoreOptions;
+};
+export type LoginResult = {
+    status: 'authenticated';
+    tokens: AuthTokens;
+    session: AuthSession;
+} | {
+    status: 'challenge';
+    challenge: AuthPasswordChangeRequired;
+};
+export interface AuthStatus {
+    session: AuthSession | null;
+    credentialStore: {
+        kind: 'session' | 'vault' | 'system' | 'managed';
+        configured: boolean;
+        locked: boolean;
+    };
+    restoration: {
+        state: 'ready' | 'restoring';
+    } | {
+        state: 'failed';
+        code: string;
+        message: string;
+    };
+}
+export interface BrowserLoginOptions {
+    requestId?: string;
+    credentialStore?: CredentialStoreOptions;
+}
+export interface BrowserLoginStatus {
+    id: string;
+    state: 'starting' | 'waiting' | 'completed' | 'cancelled' | 'failed';
+    authorizationUrl?: string;
+    session?: AuthSession;
+    error?: {
+        code: string;
+        message: string;
+        exitCode: number;
+    };
+}
+export interface SendOptions extends Partial<ExecutionDefaults> {
+    /** Narrow this run's long-term memory access within the session grant. */
+    memory?: import('../../shared/session-policy.js').RunMemoryPolicy;
+    /** Trusted host metadata. Immutable for this run, including queued dispatch and continuations. */
+    context?: import('../../shared/execution-context.js').ExecutionContext;
+    /** Default is background. Foreground is cancelled if the submitting process exits unexpectedly. */
+    execution?: 'foreground' | 'background';
+    /** 0 for unlimited; otherwise 1000..604800000 ms. */
+    timeoutMs?: number;
+    commandId?: string;
+    attachments?: Array<{
+        path: string;
+    }>;
+    attachmentIds?: string[];
+    references?: import('../../shared/local-task-api.js').LocalTaskFileReference[];
+    richContent?: import('../../shared/local-task-api.js').LocalTaskRichContent;
+    skills?: import('../../shared/local-task-api.js').LocalTaskSkillReference[];
+    plugins?: import('../../shared/local-task-api.js').LocalTaskPluginReference[];
+}
+export interface QueueSnapshot {
+    messages: import('../../shared/local-task-api.js').LocalTaskPendingMessage[];
+    queueVersion: string;
+    activeRunId: string | null;
+    historyVersion: string;
+}
+export type CommandReceipt = import('../../shared/local-task-command.js').LocalTaskCommandRecord | null;
+export interface CapabilityQuery {
+    kind?: 'tool' | 'skill';
+    category?: string;
+    enabled?: boolean;
+    available?: boolean;
+    source?: CapabilityDescriptor['source'];
+}
+export interface EffectiveCapability extends CapabilityDescriptor {
+    enabled: boolean;
+    available: boolean;
+    reason?: string;
+    operations?: Array<{
+        id: string;
+        available: boolean;
+        reason?: string;
+    }>;
+}

package/dist/shared/account-context-api.d.ts

@@ -0,0 +1,47 @@
+export interface AccountCreditSourceBalance {
+    sourceType: string | null;
+    initialPoints: number | null;
+    remainingPoints: number | null;
+    frozenPoints: number | null;
+    nearestExpiresAt: string | null;
+}
+export interface AccountContextSummary {
+    availableBalance: number | null;
+    planName: string | null;
+    planId?: string | null;
+    totalBalance?: number | null;
+    planLevel?: string | null;
+    planStatus?: string | null;
+    subscriptionId?: string | null;
+    subscriptionPlanId?: string | null;
+    subscriptionStatus?: string | null;
+    subscriptionValidFrom?: string | null;
+    subscriptionValidTo?: string | null;
+    subscriptionRemainingDays?: number | null;
+    sourceBalances?: AccountCreditSourceBalance[];
+}
+export type AccountReferralActivityStatus = 'TECHNICAL_DISABLED' | 'DISABLED' | 'UNPUBLISHED' | 'SCHEDULED' | 'ACTIVE' | 'ENDED';
+export interface AccountReferralCampaign {
+    technicalEnabled: boolean;
+    rewardEnabled: boolean;
+    activityStatus: AccountReferralActivityStatus;
+    registerRewardPoints: number | null;
+}
+export interface AccountPlanPurchase {
+    id: string;
+    planId: string;
+    planName: string;
+    subscriptionId: string | null;
+    purchasedAt: string;
+    expiresAt: string | null;
+    pointsGranted: number | null;
+    pointsRemaining: number | null;
+}
+export interface AccountContextQuery {
+    subjectName?: string;
+}
+export interface AccountContextApi {
+    getSummary: (query?: AccountContextQuery) => Promise<AccountContextSummary>;
+    getReferralCampaign: () => Promise<AccountReferralCampaign>;
+    listPlanPurchases: () => Promise<AccountPlanPurchase[]>;
+}

package/dist/shared/action-center-api.d.ts

@@ -0,0 +1,50 @@
+export interface ActionCenterSummary {
+    todoPendingCount: number;
+    messageUnreadCount: number;
+    announcementUnreadCount: number;
+}
+export interface ActionCenterTarget {
+    targetType: string | null;
+    targetRoute: string | null;
+    targetUrl: string | null;
+    openMode: string | null;
+}
+export interface ActionCenterMessage {
+    id: string;
+    sourceAppId: string | null;
+    sourceModule: string | null;
+    category: string | null;
+    level: string | null;
+    title: string;
+    content: string | null;
+    readStatus: string;
+    publishedAt: string | null;
+    createdAt: string | null;
+    target: ActionCenterTarget | null;
+    businessType?: string | null;
+    businessId?: string | null;
+    status?: string | null;
+    payload?: Record<string, unknown> | null;
+}
+export interface ActionCenterMessageQuery {
+    page: number;
+    pageSize: number;
+    readStatus?: 'unread';
+}
+export interface ActionCenterMessagePage {
+    list: ActionCenterMessage[];
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface ActionCenterNavigation {
+    url: string;
+    openMode: string | null;
+}
+export interface ActionCenterApi {
+    getSummary: () => Promise<ActionCenterSummary>;
+    listMessages: (query: ActionCenterMessageQuery) => Promise<ActionCenterMessagePage>;
+    markMessageRead: (messageId: string) => Promise<void>;
+    markAllMessagesRead: () => Promise<void>;
+    openMessageTarget: (messageId: string) => Promise<void>;
+}

package/dist/shared/agent-capabilities.d.ts

@@ -0,0 +1,42 @@
+/** Public capability IDs are independent of transport names and permissions. */
+export declare const TOOL_CATEGORIES: readonly ["workspace", "process", "repository", "web", "documents", "data", "media", "knowledge", "memory", "task-coordination", "automation", "computer", "extensions"];
+export declare const SKILL_CATEGORIES: readonly ["development", "documents", "data-research", "design", "media", "business", "automation", "agent-building"];
+export type ToolCategory = typeof TOOL_CATEGORIES[number];
+export type SkillCategory = typeof SKILL_CATEGORIES[number];
+export type AgentRuntimeMode = 'platform' | 'standalone';
+export interface CapabilitySelection<Category extends string = string> {
+    categories?: readonly Category[];
+    include?: readonly string[];
+    exclude?: readonly string[];
+}
+export interface BuiltinSelection {
+    /** AIOS-provided tools only; false leaves them unregistered. Engine tools are unchanged. */
+    tools?: boolean | CapabilitySelection<ToolCategory>;
+    /** AIOS-provided skills only; false skips materialization, discovery and injection. */
+    skills?: boolean | CapabilitySelection<SkillCategory>;
+}
+export interface CapabilityDescriptor<Category extends string = string> {
+    id: string;
+    kind: 'tool' | 'skill';
+    category: Category;
+    source: 'builtin' | 'platform' | 'application' | 'local';
+    integration: 'dynamic' | 'mcp' | 'skill';
+    requiresPlatform: boolean;
+    dependencies: readonly string[];
+    tags: readonly string[];
+    supported: boolean;
+    unavailableReason?: string;
+}
+export interface BuiltinSnapshot {
+    catalogVersion: 1;
+    mode: AgentRuntimeMode;
+    tools: string[];
+    skills: string[];
+}
+/** A saved list is the ceiling. New catalog members never expand an old task. */
+export declare function selectCapabilities<C extends string>(selection: boolean | CapabilitySelection<C>, catalog: readonly CapabilityDescriptor<C>[], categories: readonly C[], mode: AgentRuntimeMode, parent?: readonly string[]): string[];
+export declare function resolveBuiltinSnapshot(mode: AgentRuntimeMode, selection: BuiltinSelection, catalog: readonly CapabilityDescriptor[], parent?: BuiltinSnapshot): BuiltinSnapshot;
+export declare const BUILTIN_SKILL_GROUPS: Readonly<Record<SkillCategory, readonly string[]>>;
+/** Prefix families come from named registries; arbitrary extension tools never enter here. */
+export declare function describeBuiltinTool(name: string, integration: CapabilityDescriptor['integration']): CapabilityDescriptor<ToolCategory>;
+export declare const BUILTIN_SKILL_CATALOG: CapabilityDescriptor<SkillCategory>[];

package/dist/shared/agent-hooks.d.ts

@@ -0,0 +1,10 @@
+/** Host-owned lifecycle commands. They receive one JSON event on stdin and return hook JSON on stdout. */
+export interface AgentCommandHook {
+    event: 'UserPromptSubmit' | 'PreToolUse' | 'PostToolUse' | 'PreCompact' | 'PostCompact' | 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop' | 'Stop' | 'Interrupt';
+    command: string;
+    commandWindows?: string;
+    matcher?: string;
+    /** Hook execution limit only; this does not impose a task deadline. */
+    timeoutSeconds: number;
+}
+export declare function parseAgentHooks(value: unknown): AgentCommandHook[];

package/dist/shared/agent-team.d.ts

@@ -0,0 +1,17 @@
+import { type TaskPathPolicy } from './task-path-policy.js';
+import { type ModelReasoningEffort } from './model-selection.js';
+export interface AgentTeamMember {
+    id: string;
+    name: string;
+    instructions: string;
+    model?: string;
+    reasoningEffort?: ModelReasoningEffort;
+    /** AIOS tool names, intersected with the parent selection. Native tools remain constrained by the filesystem policy. */
+    tools?: string[];
+    paths?: TaskPathPolicy;
+}
+export interface AgentTeamDefinition {
+    members: AgentTeamMember[];
+    workflow?: string;
+}
+export declare function parseAgentTeam(value: unknown): AgentTeamDefinition;

package/dist/shared/artifact-evidence.d.ts

@@ -0,0 +1,18 @@
+export interface ArtifactVerification {
+    tool: string;
+    at: string;
+    fileVersion?: string;
+    origin?: 'tool_reported' | 'file_registration';
+    action?: string;
+    coverage?: Record<string, unknown>;
+}
+/** Evidence concerns only the reported checks, never a platform business verdict. */
+export interface ArtifactEvidence {
+    path: string;
+    threadId: string;
+    reportedVerified: boolean;
+    validity: 'current' | 'stale' | 'unversioned';
+    verification: ArtifactVerification;
+    previousVerification?: ArtifactVerification;
+    invalidation?: string;
+}