qlogicagent 2.20.6 → 2.20.7

package/dist/types/cli/media-understanding.d.ts

@@ -1,102 +0,0 @@
-/**
- * Shared media-understanding — single source of truth for turning a non-text medium
- * (image / audio / video) into plain text via the matching understanding model.
- *
- * Used by BOTH pipelines:
- *  - memory candidates (memory-candidate-service.ts): passes a base64 `data:` URL built
- *    from persisted attachment bytes.
- *  - the turn gate (handlers/turn-handler.ts): passes the local media-proxy URL already
- *    stamped onto the user message, so a medium the main model can't consume is routed
- *    to the understanding model and its description injected instead of dropped.
- *
- * The function is URL-agnostic on purpose: it just places whatever URL string it is given
- * onto the modality-correct message field and streams the reply. It never reads attachment
- * bytes and never persists anything — callers own storage/injection.
- */
-export type UnderstandMediaKind = "image" | "audio" | "video";
-/** Maps each medium to the ModelPurpose that understands it. */
-export declare const PURPOSE_BY_KIND: Record<UnderstandMediaKind, "imageUnderstanding" | "stt" | "videoUnderstanding">;
-/** Maps each medium to the ChatMessage field the transport reads media URLs from. */
-export declare const URL_FIELD_BY_KIND: Record<UnderstandMediaKind, "imageUrls" | "audioUrls" | "videoUrls">;
-/** Per-medium instruction. Every kind is normalized to plain text so callers only swap a label. */
-export declare const PROMPT_BY_KIND: Record<UnderstandMediaKind, string>;
-/**
- * The subset of stream-chunk fields understandMediaUrl inspects. Deliberately loose and
- * all-optional beyond `type` so it stays structurally compatible with the real LLMTransport's
- * discriminated LLMChunk union (delta / usage / error / done all satisfy it) and the memory
- * client. Beyond the `delta` text we read the `usage` tokens and the terminal `error` / `done`
- * so an empty reply can be diagnosed (medium never reached the model) rather than silently
- * reported as a blank description.
- */
-export interface UnderstandMediaChunk {
-    type: string;
-    text?: string;
-    promptTokens?: number;
-    completionTokens?: number;
-    finishReason?: string;
-    message?: string;
-}
-/**
- * A resolved understanding client. Structurally compatible with both the real LLMTransport
- * (whose `stream` takes an optional third `signal` arg) and the memory client. Deliberately
- * loose on the request/chunk shapes so it composes with either caller without import cycles.
- */
-export interface UnderstandMediaClient {
-    model: string;
-    apiKey: string;
-    transport: {
-        stream(request: object, apiKey: string, signal?: AbortSignal): AsyncIterable<UnderstandMediaChunk>;
-    };
-}
-/**
- * Why an understanding call yielded no usable text. Lets callers separate a genuine "the model
- * looked and had nothing to say" (`empty_output`) from "the medium never reached the model"
- * (`fetch_failed`) — the silent-empty failure mode where an unfetchable image (e.g. a private-OSS
- * URL the provider 403s on) bills zero input tokens, so an empty reply is a delivery failure, not
- * a blank description. `stream_error` is an explicit upstream error surfaced mid-stream.
- */
-export type MediaUnderstandFailure = "fetch_failed" | "stream_error" | "empty_output";
-/**
- * Structured outcome of understandMediaUrl. `text` is the transcript (empty ⇔ the model produced
- * no text); when `text` is empty, `failure` classifies WHY so callers can surface a delivery
- * failure distinctly instead of treating every empty reply as "nothing to describe". The token /
- * finishReason fields carry the diagnostic evidence for logs.
- */
-export interface UnderstandMediaResult {
-    /** The model's trimmed text. Empty string ⇔ no text was produced (see `failure`). */
-    text: string;
-    /** Input tokens the provider billed, if a usage chunk arrived. undefined ⇔ no usage chunk was
-     * seen at all — itself a strong "nothing reached, or came back from, the model" signal. */
-    promptTokens?: number;
-    /** Output tokens, if a usage chunk arrived. */
-    completionTokens?: number;
-    /** finishReason from the terminal chunk ("" / undefined ⇔ truncated or none). */
-    finishReason?: string;
-    /** Message from an explicit `error` chunk, if the stream surfaced one. */
-    errorText?: string;
-    /** Set when the reply is not a trustworthy result. Usually `text` is empty, but `fetch_failed` can
-     * accompany NON-empty `text` — an image billed at text-only tokens was never seen, so its "description"
-     * is confabulated. undefined ⇔ a real success; when set, callers must NOT treat `text` as valid. */
-    failure?: MediaUnderstandFailure;
-}
-/**
- * Stream an already-built understanding request and classify an empty reply. Placement of the
- * prompt and media URL(s) onto the request is the CALLER's job — this owns only the streaming +
- * diagnosis, so every vision caller (the turn gate's understandMediaUrl AND the pet forge's image
- * analysis / vision-QA) shares ONE definition of "fetch_failed vs empty_output vs stream_error"
- * instead of each re-deriving it from a thin delta-only loop. `kind` drives only the image
- * token-floor heuristic — pass the kind of the primary medium carried on the request.
- */
-export declare function streamUnderstanding(client: UnderstandMediaClient, request: Record<string, unknown>, kind: UnderstandMediaKind, opts?: {
-    signal?: AbortSignal;
-}): Promise<UnderstandMediaResult>;
-/**
- * Understand a single medium at `url`. Returns a structured result: the trimmed text (may be
- * empty) plus, when empty, a `failure` classifying WHY. Never throws for an empty reply — the
- * caller decides how to degrade, but can now tell a delivery failure (`fetch_failed`) apart from a
- * blank description (`empty_output`) instead of treating every empty reply the same. Thin wrapper
- * over streamUnderstanding that builds the single-URL, modality-correct request.
- */
-export declare function understandMediaUrl(client: UnderstandMediaClient, kind: UnderstandMediaKind, url: string, opts?: {
-    signal?: AbortSignal;
-}): Promise<UnderstandMediaResult>;

package/dist/types/cli/skill-invocation-service.d.ts

@@ -1,10 +0,0 @@
-import type { HostCapabilityClient } from "../transport/host-capability-client.js";
-export interface RunSkillInvocationParams {
-    skillName: string;
-    skillContent: string;
-    userArgs?: string;
-    skillDir?: string;
-    sessionId?: string;
-    hostCapabilityClient: HostCapabilityClient;
-}
-export declare function runSkillInvocation(params: RunSkillInvocationParams): Promise<string>;

package/dist/types/cli/skill-tools-bootstrap.d.ts

@@ -1,35 +0,0 @@
-import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { MemoryLearningSink, PathService, ToolCatalog } from "../runtime/ports/index.js";
-import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
-import type { HostCapabilityClient } from "../transport/host-capability-client.js";
-export interface SkillToolsBootstrapDeps {
-    config: Record<string, unknown>;
-    pathService: PathService;
-    toolCatalog: ToolCatalog;
-}
-export type SkillLearningMemorySink = MemoryLearningSink;
-export interface SkillToolsHost {
-    getActiveProjectRoot(): string;
-    getPluginSkills(): WorkspaceSkill[];
-    getHostCapabilityClient(): HostCapabilityClient | undefined;
-    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-    getMemoryLearningSink(): SkillLearningMemorySink | null;
-    getMemoryUserId(): string;
-}
-export interface SkillToolsRegistrationContext extends SkillToolsBootstrapDeps {
-    host: SkillToolsHost;
-}
-export declare const skillToolsRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillToolsRegistrationContext>;
-export declare function configureSkillToolsBootstrap(host: SkillToolsHost, deps: SkillToolsBootstrapDeps): void;
-/**
- * Resolve a supporting-file path inside a skill folder.
- * Returns the absolute target, or null when the path escapes the skill dir
- * or targets SKILL.md itself (SKILL.md must go through the validated
- * content path, never the raw supporting-file write).
- */
-export declare function resolveSupportingFilePath(skillDir: string, filePath: string): string | null;
-/**
- * 读技能文件:ENOENT(文件不存在)→ null(语义 = 技能/文件未安装);其余失败
- * (EPERM/EISDIR 等)抛出真实错误 —— 读失败不能伪装成"技能不存在"。导出仅为单测。
- */
-export declare function readSkillFileOrNull(label: string, filePath: string): Promise<string | null>;

package/dist/types/cli/skills-query-service.d.ts

@@ -1,41 +0,0 @@
-import type { HostCapabilityClient } from "../transport/host-capability-client.js";
-export interface SkillListEntry {
-    id: string;
-    name: string;
-    path: string;
-    /** Effective in this project: not globally muted and not muted in this project. */
-    active: boolean;
-    /** Muted everywhere (the plugin card's off switch). */
-    globallyDisabled: boolean;
-    /** Muted in THIS project only (the project opt-out). */
-    projectDisabled: boolean;
-    /** Frontmatter classification (Hub category vocabulary) — drives the card palette/tag. Undefined for unclassified legacy skills. */
-    category?: string;
-    /** Frontmatter author — agent-authored skills carry "用户". */
-    author?: string;
-    /** Provenance (lifecycle store): learned/created/promoted/copied = local origin; "installed" = from the Hub. */
-    source?: "learned" | "created" | "installed" | "promoted";
-    displayName: {
-        key: string;
-        fallback: string;
-    };
-    displayDescription: {
-        key: string;
-        fallback: string;
-    };
-    fallbackName: string;
-    fallbackDescription: string;
-    systemGenerated: boolean;
-    version?: string;
-    /** Registry version actually installed (from the lifecycle store) — same
-     *  namespace as the catalog's latestVersion, so the UI can detect
-     *  installed < latest and offer an update. Absent for non-registry skills. */
-    registryVersion?: string;
-    description?: string;
-}
-/**
- * List every skill in the single global store, annotated with its enablement
- * scope and whether it is active in the given project. Name-collisions cannot
- * occur (one directory per name in the store), so each skill appears once.
- */
-export declare function listSkillsForProject(capability: HostCapabilityClient | undefined, projectRoot?: string): Promise<SkillListEntry[]>;

package/dist/types/cli/tool-bootstrap-media-registration.d.ts

@@ -1,20 +0,0 @@
-import type { PortableTool } from "../skills/portable-tool.js";
-import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
-import { type ModelPurpose } from "../runtime/infra/model-registry.js";
-import type { LLMTransport } from "./provider-core-facade.js";
-export interface LocalMediaToolRegistrationContext {
-    tools: PortableTool<any>[];
-    getCwd(): string;
-    activeProjectRoot(): string;
-    mediaPersistence?: MediaPersistence;
-    /** Resolves the LLM client bound to a model purpose — needed by the image/video understanding
-     * tools, which run the imageUnderstanding / videoUnderstanding purpose model (a vision LLM),
-     * NOT the media-generation runtime that stt/generation ride. Absent → those tools are skipped. */
-    resolveClientForPurpose?(purpose: ModelPurpose): {
-        transport: LLMTransport;
-        apiKey: string;
-        model: string;
-    } | null;
-}
-export declare const localMediaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalMediaToolRegistrationContext>;
-export declare function registerLocalMediaTools(context: LocalMediaToolRegistrationContext): void;

package/dist/types/cli/turn-media-setup.d.ts

@@ -1,34 +0,0 @@
-import type { TurnConfig } from "../agent/types.js";
-import { type ModelRegistry } from "../runtime/infra/model-registry.js";
-import { type MediaClient } from "./provider-core-facade.js";
-interface MediaUsageRecorder {
-    addMediaUsage(model: string, billingUnit: string, quantity: number): void;
-}
-export interface TurnMediaSetupHost {
-    mediaClient: MediaClient;
-    currentMediaApiKeys: Record<string, string> | null;
-    sessionState?: MediaUsageRecorder | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-}
-export declare function deriveMediaProvidersFromBindings(registry: Pick<ModelRegistry, "getBinding">): TurnConfig["mediaProviders"];
-/**
- * Derive per-turn media providers from a Host-pushed session profile's bindings. The Host materializes
- * and pushes a FRESH profile every turn (session/set_config "profile") covering every purpose — media
- * ones included (imageGeneration/tts/videoGeneration/musicGeneration/threeDGeneration/stt/voiceClone).
- * Threading these into config.mediaProviders lets the fresh binding WIN over the once-hydrated in-process
- * ModelRegistry default: configureTurnMedia merges config.mediaProviders OVER deriveMediaProvidersFromBindings,
- * so a media purpose is no longer pinned to the registry snapshot until a process reload. Uses the same
- * MEDIA_PURPOSES purpose→capability map as the registry path (single source of truth) and the same
- * nativeModelId ?? model rule (profile bindings carry no nativeModelId today, so this resolves to model).
- */
-export declare function deriveMediaProvidersFromProfileBindings(bindings: Record<string, {
-    provider?: string;
-    model?: string;
-    nativeModelId?: string;
-}>): TurnConfig["mediaProviders"];
-export declare function configureTurnMedia(params: {
-    host: TurnMediaSetupHost;
-    config?: Record<string, unknown>;
-    turnId: string;
-}): void;
-export {};

package/dist/types/cli/turn-preview-browser-setup.d.ts

@@ -1,15 +0,0 @@
-import type { HostRequestClient } from "../transport/host-request-client.js";
-import type { PreviewBrowserDriveResult, PreviewBrowserToolParams } from "../skills/tools/preview-browser-tool.js";
-export interface TurnPreviewBrowserSetupHost {
-    /** The coordinator-owned unary host client, or undefined when no host is attached. */
-    getHostRequestClient(): Pick<HostRequestClient, "request"> | undefined;
-    /** Active turn attribution; injected into preview params, never accepted from agent tool input. */
-    readonly currentSessionId: string;
-}
-/**
- * Build the preview_browser backend over the coordinator-owned HostRequestClient. The action is the
- * service method and is removed from the action-specific payload. Preview owns an explicit 15s
- * policy; failures remain visible as `{ error }`.
- */
-export declare function makePreviewBrowserBackend(host: TurnPreviewBrowserSetupHost): (params: PreviewBrowserToolParams, signal?: AbortSignal) => Promise<PreviewBrowserDriveResult>;
-export declare function configureTurnPreviewBrowser(host: TurnPreviewBrowserSetupHost): void;

package/dist/types/runtime/infra/astraclaw-capabilities.d.ts

@@ -1,33 +0,0 @@
-import type { ToolCatalog } from "../ports/index.js";
-export declare const ASTRACLAW_CAPABILITIES_SERVER_NAME = "astraclaw_capabilities";
-export declare const ASTRACLAW_CAPABILITIES_RETIRED_SERVER_NAMES: readonly ["astraclaw"];
-export interface AstraClawCapabilityToolInput {
-    tool: string;
-    args: Record<string, unknown>;
-    projectRoot: string;
-    availableToolNames?: Iterable<string>;
-    currentEnvironment?: string;
-    toolCatalog?: ToolCatalog;
-    /**
-     * Configured MCP servers serving NO tools this session (invalid config / connect failure).
-     * Disclosed in mcp_connectors_list so a failed server is visibly missing, not silently absent.
-     */
-    mcpServerFailures?: Array<{
-        name: string;
-        phase?: string;
-        error: string;
-    }>;
-}
-export type AstraClawCapabilityToolResult = {
-    handled: false;
-} | {
-    handled: true;
-    result: unknown;
-};
-export declare function buildAstraClawCapabilitiesSystemPrompt(input: {
-    projectRoot: string;
-    mcpAvailable: boolean;
-    availableToolNames?: Iterable<string>;
-    currentEnvironment?: string;
-}): Promise<string | undefined>;
-export declare function handleAstraClawCapabilityToolCall(input: AstraClawCapabilityToolInput): Promise<AstraClawCapabilityToolResult>;

package/dist/types/runtime/infra/builtin-skills-seed.d.ts

@@ -1,31 +0,0 @@
-export interface SeedBuiltinSkillsOptions {
-    /** Global skill store dir (getUserSkillsDir()). Each skill lands at <storeDir>/<name>/SKILL.md. */
-    storeDir: string;
-    /** Override the shipped builtin-skills source dir; defaults to the packaged skills/builtin. */
-    builtinDir?: string;
-}
-export interface SeedBuiltinSkillsResult {
-    /** Names of skills newly copied this run (empty when all already present or source missing). */
-    seeded: string[];
-}
-/**
- * Locate the shipped skills/builtin directory from a module directory.
- *
- * The module dir differs by packaging mode — crucially, the production build is an esbuild
- * BUNDLE: this module is inlined into dist/cli.js, so at runtime import.meta.url resolves to
- * dist/cli.js itself, NOT dist/runtime/infra/... Probe candidates in order:
- * 1. hereDir/skills/builtin           — bundle: hereDir = dist/ → dist/skills/builtin
- *                                       (build.mjs copies skills/builtin there).
- * 2. hereDir/../../skills/builtin     — unbundled dist module at dist/runtime/infra/.
- * 3. hereDir/../../../skills/builtin  — dev/tsx/vitest: src/runtime/infra → repo-root skills/builtin.
- * Returns the first candidate that exists, or undefined when none does (stripped-down build).
- * Exported pure (hereDir in → path out) so tests can drive it against synthetic layouts.
- */
-export declare function resolveBuiltinDirFrom(hereDir: string): string | undefined;
-/**
- * Copy each builtin skill directory into the store only when its target does not yet exist.
- * Idempotent: a second run with everything already present returns { seeded: [] }.
- * Missing builtinDir is not an error — returns { seeded: [] } so a stripped-down build
- * (or a local checkout without the assets) never blocks startup.
- */
-export declare function seedBuiltinSkills(options: SeedBuiltinSkillsOptions): SeedBuiltinSkillsResult;

package/dist/types/runtime/infra/checkpoint-backend.d.ts

@@ -1,9 +0,0 @@
-/**
- * Local Checkpoint Backend — git-based shadow repo implementation.
- *
- * Creates and manages checkpoint snapshots in the centralized companion store
- * `~/.qlogicagent/projectData/<projectId>/checkpoints/<sessionId>/`
- * (NOT inside the user's workspace) using a shadow git repository independent of the user's .git.
- */
-import type { CheckpointBackend } from "../ports/checkpoint-contracts.js";
-export declare function createLocalCheckpointBackend(projectRoot: string, sessionId: string): CheckpointBackend;

package/dist/types/runtime/infra/industrial-runtime-session-server.d.ts

@@ -1,20 +0,0 @@
-import type { ConfigPort } from "../ports/index.js";
-export interface IndustrialRuntimeChildEnv {
-    XIAOZHICLAW_RUNTIME_SESSION_URL: string;
-    XIAOZHICLAW_RUNTIME_SESSION_BEARER: string;
-    XIAOZHICLAW_RUNTIME_CONVERSATION_ID?: string;
-    XIAOZHICLAW_RUNTIME_CREDENTIAL_SUBJECT: string;
-}
-type ProbeSession = (signal: AbortSignal) => Promise<Response>;
-export interface IndustrialRuntimeSessionServerForTest {
-    childEnv(sessionId?: string): IndustrialRuntimeChildEnv;
-    stop(): Promise<void>;
-}
-export declare function industrialRuntimeSessionChildEnv(sessionId?: string): Promise<IndustrialRuntimeChildEnv | undefined>;
-export declare function stopIndustrialRuntimeSessionServer(): Promise<void>;
-export declare function __createIndustrialRuntimeSessionServerForTest(options: {
-    probeSession: ProbeSession;
-    configPort?: ConfigPort;
-    fetch?: typeof fetch;
-}): Promise<IndustrialRuntimeSessionServerForTest>;
-export {};

package/dist/types/runtime/infra/migrate-project-skills.d.ts

@@ -1,24 +0,0 @@
-/**
- * One-shot migration: fold legacy per-project skill directories
- * (`<projectRoot>/.qlogicagent/skills/<name>/`) into the single global store.
- *
- * Under the opt-out model every skill is global, so a freshly-migrated skill is parked GLOBALLY
- * DISABLED — the same default as an agent-learned skill. The user re-enables it deliberately from
- * the plugins page; a once-project-scoped skill must NOT silently light up in every project.
- *
- * Idempotent — a no-op once the legacy directory is gone, so it is safe to call on every project
- * activation. Conflict-safe — if a DIFFERENT skill of the same name already exists in the store, the
- * legacy copy is LEFT IN PLACE with a loud warning and never silently overwritten.
- */
-export interface SkillMigrationResult {
-    /** Moved into the store fresh (parked globally disabled). */
-    migrated: string[];
-    conflicts: string[];
-    /** Already present in the store with identical content; legacy copy dropped, store entry untouched. */
-    reconciled: string[];
-}
-/**
- * Migrate one project's legacy skills into the global store. Best-effort and
- * idempotent. Returns a summary of what happened.
- */
-export declare function migrateProjectSkills(projectRoot: string): SkillMigrationResult;

package/dist/types/runtime/infra/project-skill-manifest.d.ts

@@ -1,21 +0,0 @@
-/**
- * Skill mute registries — under the single-store model, EVERY skill is global. There is no
- * project-scoped / opt-in concept; instead there are two opt-OUT mute lists:
- *
- *   - device-level (~/.qlogicagent/skills-disabled.json) — off in EVERY project
- *     (the plugin card's on/off switch; also where agent-learned skills land, disabled, until the
- *     user reviews and enables them). 与技能 store 同域:插件及其开关都是设备资产,登录身份切换
- *     不得改变哪些技能是开着的(此前 per-owner 键控会让 A 身份停放的技能在 B 身份下点亮)。
- *   - per-project  (<cwd>/.qlogicagent/skills-disabled.json)              — off in THIS project only
- *     (the "project skills" opt-out, to cut down which skills an agent sees in a given project).
- *
- *   active(project) = stored skill  AND  name ∉ globally-disabled  AND  name ∉ project-disabled
- */
-/** Globally muted skills (inactive everywhere). */
-export declare function readGloballyDisabledSkills(): Set<string>;
-/** Mute/unmute a skill globally. Idempotent. Returns true if the registry changed. */
-export declare function setSkillGloballyDisabled(name: string, disabled: boolean): boolean;
-/** Skills muted in this project (inactive here, active elsewhere unless globally muted). */
-export declare function readProjectDisabledSkills(cwd: string): Set<string>;
-/** Mute/unmute a skill in this project. Idempotent. Returns true if the manifest changed. */
-export declare function setProjectSkillDisabled(cwd: string, name: string, disabled: boolean): boolean;

package/dist/types/runtime/infra/skill-resolver.d.ts

@@ -1,74 +0,0 @@
-/**
- * Skill resolver — single source of truth for "which skills are effective in a given project".
- *
- * Storage: ONE global store at getUserSkillsDir(). Every skill is global; two opt-out mute lists
- * decide effectiveness — owner-level (off everywhere) and per-project (off in this project). See
- * project-skill-manifest.
- *
- *   active(project) = stored skill  AND  name ∉ globally-disabled  AND  name ∉ project-disabled
- *
- * All resolution / listing / injection surfaces MUST go through this module so precedence lives in
- * exactly one place. Kept in runtime/infra (no skills-layer imports) so both runtime and cli callers
- * may use it without crossing the runtime → skills boundary.
- */
-export interface ResolvedSkill {
-    name: string;
-    /** Absolute path to <store>/<name>/SKILL.md */
-    filePath: string;
-    /** Absolute path to <store>/<name> */
-    baseDir: string;
-    /** Muted everywhere (the plugin card's off switch / agent-learned-pending-review). */
-    globallyDisabled: boolean;
-    /** Muted in THIS project's context (the per-project opt-out). */
-    projectDisabled: boolean;
-    /** Effective here: neither globally nor project muted. */
-    active: boolean;
-    systemGenerated: boolean;
-    description?: string;
-    version?: string;
-    /** Frontmatter classification (Hub category vocabulary: efficiency/dev/writing/…) — drives the card palette. */
-    category?: string;
-    /** Frontmatter author — agent-authored skills carry "用户". */
-    author?: string;
-    requiredTools?: string[];
-    environments?: string[];
-}
-export declare function isSystemGeneratedSkillName(name: string): boolean;
-export interface SkillActivationContext {
-    availableToolNames?: Iterable<string>;
-    currentEnvironment?: string;
-}
-/**
- * Resolve all skills in the global store, annotated with global/project mute state and whether
- * they're active in the given project context.
- *
- * Returns ALL store skills (active and inactive) so listing surfaces can show enable/disable state;
- * callers that only want active skills filter `.active` (or use resolveActiveSkills).
- */
-export declare function resolveSkills(projectRoot?: string, activation?: SkillActivationContext): ResolvedSkill[];
-/** Only the skills active in the given project (for the system-prompt skills catalog / resolution). */
-export declare function resolveActiveSkills(projectRoot?: string, activation?: SkillActivationContext): ResolvedSkill[];
-/**
- * Async, NON-BLOCKING, cached twin of {@link resolveSkills} for the first-token hot path
- * ({@link createAvailableSkillsSection}). Returns ALL store skills annotated with mute/active state,
- * exactly like {@link resolveSkills}, but reads off the event loop and reuses cached parse results when
- * the store is unchanged. The sync {@link resolveSkills} is deliberately left intact for other callers.
- */
-export declare function resolveSkillsAsync(projectRoot?: string, activation?: SkillActivationContext): Promise<ResolvedSkill[]>;
-/** Async twin of {@link resolveActiveSkills}: only the skills active in the given project context. */
-export declare function resolveActiveSkillsAsync(projectRoot?: string, activation?: SkillActivationContext): Promise<ResolvedSkill[]>;
-/** Test-only: drop the async raw-skill cache so each test observes a cold read. */
-export declare function __clearSkillResolveCacheForTests(): void;
-/**
- * Resolve a single skill by name to its store paths, or null if not present.
- * Resolution honors only the global store (single source of truth) and ignores
- * enablement — any stored skill is invocable by explicit name.
- */
-export declare function resolveSkillPath(name: string): {
-    baseDir: string;
-    filePath: string;
-} | null;
-export declare function skillConditionsMatch(meta: {
-    requiredTools?: string[];
-    environments?: string[];
-}, activation: SkillActivationContext | undefined): boolean;

package/dist/types/runtime/infra/worktree-backend.d.ts

@@ -1,86 +0,0 @@
-/**
- * Worktree Backend — git command implementation for WorktreeToolDeps.
- *
- * CC reference: claude-code-haha/src/utils/worktree.ts
- *
- * Implements the host-provided git worktree backend:
- *   - enterWorktree(): git worktree add -B <branch> <path> HEAD
- *   - exitWorktree(): git worktree remove / keep
- *   - listWorktrees(): git worktree listporcelain
- *   - isInWorktree(): check if cwd is inside a worktree
- *   - currentWorktree(): get current worktree info
- *
- * State management:
- *   - Tracks current worktree session in memory
- *   - CWD switching via process.chdir()
- *   - Safety checks: uncommitted changes, unpushed commits
- *
- * Security: validateWorktreeSlug() prevents path traversal.
- */
-import type { WorktreeBackend } from "../ports/worktree-contracts.js";
-interface WorktreeSession {
-    originalCwd: string;
-    worktreePath: string;
-    worktreeName: string;
-    worktreeBranch: string;
-    /** tmux session name (CC parity). */
-    tmuxSessionName?: string;
-    /** Whether worktree was created via a user hook (CC hookBased). */
-    hookBased?: boolean;
-    /** Creation duration in ms (unset on resume). */
-    creationDurationMs?: number;
-    /** True if sparse-checkout was applied. */
-    usedSparsePaths?: boolean;
-}
-/** Get the current worktree session (CC getCurrentWorktreeSession parity). */
-export declare function getCurrentWorktreeSession(): WorktreeSession | null;
-/** Restore session on resume (CC restoreWorktreeSession parity). */
-export declare function restoreWorktreeSession(session: WorktreeSession | null): void;
-export declare function findGitRoot(cwd?: string): Promise<string | null>;
-/** Check whether tmux is available on the system. */
-export declare function isTmuxAvailable(): Promise<boolean>;
-/** Generate a tmux session name from repo path and branch (CC parity). */
-export declare function generateTmuxSessionName(repoPath: string, branch: string): string;
-/**
- * Create a tmux session for a worktree (CC createTmuxSessionForWorktree parity).
- * Returns the session name, or null if tmux is not available.
- */
-export declare function createTmuxSession(worktreePath: string, sessionName: string): Promise<string | null>;
-/** Kill a tmux session (CC killTmuxSession parity). */
-export declare function killTmuxSession(sessionName: string): Promise<boolean>;
-/**
- * Create a lightweight worktree for a sub-agent without modifying the
- * global session. CC reference: createAgentWorktree().
- */
-export declare function createAgentWorktree(gitRoot: string, slug: string, log?: {
-    info(msg: string): void;
-    warn(msg: string): void;
-}): Promise<{
-    worktreePath: string;
-    branch: string;
-} | null>;
-/** Remove an agent worktree (CC removeAgentWorktree parity). */
-export declare function removeAgentWorktree(gitRoot: string, worktreePath: string, branch: string, log?: {
-    info(msg: string): void;
-    warn(msg: string): void;
-}): Promise<boolean>;
-/**
- * Clean up stale agent worktrees older than maxAgeDays (CC cleanupStaleAgentWorktrees parity).
- */
-export declare function cleanupStaleAgentWorktrees(gitRoot: string, maxAgeDays?: number, log?: {
-    info(msg: string): void;
-    warn(msg: string): void;
-}): Promise<number>;
-export interface WorktreeBackendOptions {
-    /** Logger for worktree operations */
-    log: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-    /** Directories to symlink from main repo (CC parity: node_modules, etc.) */
-    symlinkDirs?: string[];
-    /** Sparse-checkout paths (CC settings.worktree.sparsePaths parity). */
-    sparsePaths?: string[];
-}
-export declare function createWorktreeBackend(opts: WorktreeBackendOptions): WorktreeBackend;
-export {};

package/dist/types/runtime/ports/checkpoint-contracts.d.ts

@@ -1,19 +0,0 @@
-export interface Checkpoint {
-    id: string;
-    message: string;
-    timestamp: string;
-    fileCount: number;
-}
-export interface CheckpointResult {
-    success: boolean;
-    checkpoint?: Checkpoint;
-    checkpoints?: Checkpoint[];
-    diff?: string;
-    error?: string;
-}
-export interface CheckpointBackend {
-    createCheckpoint(message?: string): Promise<CheckpointResult>;
-    listCheckpoints(): Promise<CheckpointResult>;
-    restoreCheckpoint(checkpointId: string, paths?: string[]): Promise<CheckpointResult>;
-    diffCheckpoint(checkpointId: string): Promise<CheckpointResult>;
-}

package/dist/types/runtime/ports/worktree-contracts.d.ts

@@ -1,22 +0,0 @@
-export interface WorktreeInfo {
-    name: string;
-    path: string;
-    branch: string;
-    isCurrent: boolean;
-    hasChanges: boolean;
-    unpushedCommits: number;
-}
-export interface WorktreeResult {
-    success: boolean;
-    worktree?: WorktreeInfo;
-    worktrees?: WorktreeInfo[];
-    previousCwd?: string;
-    error?: string;
-}
-export interface WorktreeBackend {
-    enterWorktree(name?: string): Promise<WorktreeResult>;
-    exitWorktree(action: "keep" | "remove", discardChanges?: boolean): Promise<WorktreeResult>;
-    listWorktrees(): Promise<WorktreeResult>;
-    isInWorktree(): boolean;
-    currentWorktree?(): WorktreeInfo | null;
-}

package/dist/types/skills/mcp/astraclaw-native-mcp-server.d.ts

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