cann-workbench 0.0.0-stage → 0.0.2-alpha

package/lib/index.d.ts

@@ -0,0 +1,722 @@
+import { z } from "zod";
+import { RemoteResult, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import z$1 from "@deepseek-ai/schemastery";
+import { Context } from "@deepseek-ai/cordis";
+import "@deepseek-ai/dsh-fs";
+declare const visualTypes: readonly ["code-change", "execution-console", "profile-flamegraph", "instruction-timeline", "memory-chart"];
+type VisualType = typeof visualTypes[number];
+interface Source {
+  type: 'tool' | 'profiler' | 'file' | 'sample';
+  reference: string;
+  collectedAt: string;
+  device: string | null;
+  captureMode: 'hardware' | 'simulator' | 'sampling' | 'record' | null;
+}
+interface CodeData {
+  contract: 'code-change/1';
+  changeId: string;
+  toolCallId: string | null;
+  path: string;
+  language: string | null;
+  operation: 'create' | 'modify' | 'delete';
+  status: 'proposed' | 'applied' | 'failed' | 'reverted';
+  comparisonScope: 'file' | 'fragment';
+  baselineState: 'known' | 'new-file' | 'unavailable';
+  oldText: string | null;
+  newText: string;
+  oldStartLine: number | null;
+  newStartLine: number | null;
+  baseRevision: string | null;
+  resultRevision: string | null;
+  source: Source;
+}
+interface LogChunk {
+  id: string;
+  sequence: number;
+  channel: 'stdout' | 'stderr' | 'pty' | 'log';
+  text: string;
+  gapBefore: boolean;
+}
+interface ConsoleData {
+  contract: 'execution-console/1';
+  runId: string;
+  toolCallId: string | null;
+  command: string;
+  cwd: string | null;
+  phase: 'build' | 'run' | 'test' | 'command';
+  status: 'waiting' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'unknown';
+  startedAt: string | null;
+  finishedAt: string | null;
+  exitCode: number | null;
+  signal: string | null;
+  outputMode: 'live' | 'record';
+  chunks: LogChunk[];
+  nextSequence: number;
+  hasGap: boolean;
+  fullLogRef: string | null;
+  source: Source;
+}
+interface FlameNode {
+  id: string;
+  parentId: string | null;
+  name: string;
+  selfCost: number;
+  sourceLocation: {
+    path: string;
+    line: number;
+  } | null;
+}
+interface FlameData {
+  contract: 'profile-flamegraph/1';
+  datasetId: string;
+  mode: 'aggregate';
+  measure: 'cpu-samples' | 'call-cost';
+  unit: 'samples' | 'us' | 'ns' | 'bytes';
+  nodes: FlameNode[];
+  source: Source;
+}
+interface Lane {
+  id: string;
+  coreId: string;
+  label: string;
+}
+interface TimelineEvent {
+  id: string;
+  laneId: string;
+  label: string;
+  start: number;
+  end: number;
+  instructionId: string | null;
+  opcode: string | null;
+  dependencyIds: string[] | null;
+  sourceLocation: {
+    path: string;
+    line: number;
+  } | null;
+}
+interface TimelineData {
+  contract: 'instruction-timeline/1';
+  traceId: string;
+  mode: 'pipe-trace' | 'instruction';
+  clockId: string;
+  unit: 'us' | 'ns' | 'cycles';
+  lanes: Lane[];
+  events: TimelineEvent[];
+  source: Source;
+}
+interface MemoryPoint {
+  id: string;
+  time: number;
+  value: number | null;
+}
+interface MemoryData {
+  contract: 'memory-chart/1';
+  datasetId: string;
+  mode: 'series' | 'summary';
+  memoryKind: string;
+  metric: 'capacity' | 'bandwidth' | 'utilization';
+  unit: 'bytes' | 'GB/s' | 'percent';
+  clockId: string | null;
+  timeUnit: 'us' | 'ms' | 's' | null;
+  capacity: number | null;
+  series: {
+    id: string;
+    label: string;
+    role: 'allocated' | 'reserved' | 'held' | 'observed';
+    points: MemoryPoint[];
+  }[];
+  summary: {
+    current: number | null;
+    peak: number;
+    seriesId: string | null;
+  };
+  source: Source;
+}
+type VisualData = CodeData | ConsoleData | FlameData | TimelineData | MemoryData;
+interface VisualInput {
+  schema: 'cann.sidebar.component-input/1';
+  componentId: string;
+  componentType: VisualType;
+  contextRef: string | null;
+  revision: number;
+  availability: 'loading' | 'empty' | 'ready' | 'error' | 'stale';
+  data: VisualData | null;
+  error: {
+    code: string;
+    message: string;
+    recoverable: boolean;
+  } | null;
+}
+interface TimeRange {
+  clockId: string;
+  unit: string;
+  start: number;
+  end: number;
+}
+type VisualAction = {
+  kind: 'code.select';
+  changeId: string;
+  path: string;
+  side: 'before' | 'after';
+  fromLine: number;
+  toLine: number;
+} | {
+  kind: 'playback.change';
+  changeId: string;
+  state: 'playing' | 'paused' | 'finished';
+  action: 'pause' | 'resume' | 'show-final' | 'replay';
+} | {
+  kind: 'console.select';
+  runId: string;
+  fromSequence: number;
+  toSequence: number;
+} | {
+  kind: 'console.follow';
+  runId: string;
+  following: boolean;
+} | {
+  kind: 'flame.select';
+  datasetId: string;
+  nodeId: string;
+} | {
+  kind: 'flame.focus';
+  datasetId: string;
+  rootId: string | null;
+} | {
+  kind: 'timeline.select';
+  traceId: string;
+  eventIds: string[];
+} | {
+  kind: 'timeline.range';
+  traceId: string;
+  range: TimeRange;
+  coreIds: string[];
+  laneIds: string[];
+} | {
+  kind: 'memory.select';
+  datasetId: string;
+  seriesId: string;
+  pointId: string;
+} | {
+  kind: 'memory.range';
+  datasetId: string;
+  seriesIds: string[];
+  range: TimeRange;
+};
+interface VisualEvent {
+  schema: 'cann.sidebar.component-event/1';
+  eventId: string;
+  componentId: string;
+  componentType: VisualType;
+  contextRef: string | null;
+  inputRevision: number;
+  occurredAt: string;
+  action: VisualAction;
+}
+interface VisualUpdate {
+  schema: 'cann.sidebar.component-update/1';
+  componentId: string;
+  componentType: 'execution-console';
+  contextRef: string | null;
+  baseRevision: number;
+  revision: number;
+  update: {
+    kind: 'console.append';
+    runId: string;
+    chunks: LogChunk[];
+    nextSequence: number;
+    hasGap: boolean;
+  } | {
+    kind: 'console.finish';
+    runId: string;
+    status: 'succeeded' | 'failed' | 'cancelled' | 'unknown';
+    finishedAt: string;
+    exitCode: number | null;
+    signal: string | null;
+  };
+}
+declare const saveSessionResourcesSchema: z.ZodObject<{
+  sessionId: z.ZodString;
+  selection: z.ZodObject<{
+    environmentIds: z.ZodArray<z.ZodString>;
+    skillIds: z.ZodArray<z.ZodString>;
+    knowledgeBaseIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>;
+  revision: z.ZodString;
+}, z.core.$strict>;
+declare const sessionResourcesSchema: z.ZodObject<{
+  sessionId: z.ZodString;
+  revision: z.ZodString;
+  selection: z.ZodObject<{
+    environmentIds: z.ZodArray<z.ZodString>;
+    skillIds: z.ZodArray<z.ZodString>;
+    knowledgeBaseIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>;
+  unavailable: z.ZodObject<{
+    environmentIds: z.ZodArray<z.ZodString>;
+    skillIds: z.ZodArray<z.ZodString>;
+    knowledgeBaseIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>;
+  environments: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    username: z.ZodString;
+    soc: z.ZodString;
+    connect: z.ZodEnum<{
+      unknown: "unknown";
+      checking: "checking";
+      online: "online";
+      offline: "offline";
+    }>;
+    checkedAt: z.ZodOptional<z.ZodNumber>;
+    device: z.ZodOptional<z.ZodObject<{
+      soc: z.ZodString;
+      driverVersion: z.ZodString;
+      firmwareVersion: z.ZodString;
+      cannPackages: z.ZodArray<z.ZodObject<{
+        dir: z.ZodString;
+        version: z.ZodString;
+      }, z.core.$strip>>;
+      devices: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  skills: z.ZodObject<{
+    groups: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodString;
+        zh: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>]>;
+      repository: z.ZodString;
+      revision: z.ZodOptional<z.ZodString>;
+      skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        skillName: z.ZodString;
+        path: z.ZodString;
+        sourceId: z.ZodString;
+        name: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+          en: z.ZodString;
+          zh: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        description: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+          en: z.ZodString;
+          zh: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    errors: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      message: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  knowledgeBases: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    transport: z.ZodEnum<{
+      http: "http";
+      stdio: "stdio";
+    }>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SessionResources = z.infer<typeof sessionResourcesSchema>;
+type SaveSessionResources = z.infer<typeof saveSessionResourcesSchema>;
+declare const taskStatusSchema: z.ZodEnum<{
+  pending: "pending";
+  running: "running";
+  blocked: "blocked";
+  completed: "completed";
+  failed: "failed";
+}>;
+type TaskStatus = z.infer<typeof taskStatusSchema>;
+interface TaskResourceSelection {
+  readonly requirementId: string;
+  readonly resourceIds: readonly string[];
+}
+type TaskMetadataStatus = TaskStatus;
+type TaskGraphNodeState = 'pending' | 'active' | 'completed' | 'failed' | 'skipped';
+interface TaskGraphNode {
+  readonly id: string;
+  readonly title: import('@deepseek-ai/dsh-package-manifest').LocalizedText;
+  readonly kind: 'intent' | 'spec' | 'implement' | 'build' | 'test' | 'debug' | 'profile' | 'optimize' | 'review' | 'package' | 'custom';
+  readonly phase: 'planning' | 'implementation' | 'validation' | 'tuning' | 'review' | 'delivery';
+  readonly description?: import('@deepseek-ai/dsh-package-manifest').LocalizedText;
+  readonly required?: boolean;
+  readonly retryable?: boolean;
+}
+interface TaskGraphEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly kind: 'sequential' | 'retry' | 'feedback' | 'conditional';
+  readonly condition?: import('@deepseek-ai/dsh-package-manifest').LocalizedText;
+}
+interface TaskGraph {
+  readonly nodes: readonly TaskGraphNode[];
+  readonly edges: readonly TaskGraphEdge[];
+}
+interface TaskGraphNodeStatus {
+  readonly nodeId: string;
+  readonly state: TaskGraphNodeState;
+  readonly enteredAt?: string;
+  readonly settledAt?: string;
+  readonly attempt?: number;
+  readonly evidence?: readonly string[];
+  /** One-line stage outcome rendered under the node in the task sidebar. */
+  readonly summary?: string;
+  /** Machine-readable stage payload keyed by field name; rendered as labeled rows. */
+  readonly structured?: Readonly<Record<string, unknown>>;
+}
+interface TaskMetadata {
+  readonly components?: readonly VisualInput[];
+  readonly id: string;
+  readonly title: string;
+  readonly definitionId: string;
+  readonly definitionVersion: string;
+  readonly status: TaskMetadataStatus;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly workflow: TaskGraph;
+  readonly currentNodeIds?: readonly string[];
+  readonly blockedReason?: string;
+  readonly nodeStatuses?: readonly TaskGraphNodeStatus[];
+  readonly resources?: readonly TaskResourceSelection[];
+  readonly inputs?: Readonly<Record<string, unknown>>;
+}
+declare const prepareInteractionRequestSchema: z.ZodObject<{
+  requestId: z.ZodUUID;
+  sessionId: z.ZodString;
+  intent: z.ZodObject<{
+    eventId: z.ZodUUID;
+    sessionId: z.ZodString;
+    workspaceId: z.ZodString;
+    taskId: z.ZodString;
+    taskUpdatedAt: z.ZodString;
+    locale: z.ZodEnum<{
+      en: "en";
+      zh: "zh";
+    }>;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"component.explain">;
+      event: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodJSONSchema>, z.ZodTransform<VisualEvent, Record<string, z.core.util.JSONType>>>;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"workflow.explain">;
+      nodeId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"metrics.explain">;
+      reportId: z.ZodString;
+      metricId: z.ZodEnum<{
+        task_duration_us: "task_duration_us";
+        mte2_ratio: "mte2_ratio";
+        mte3_ratio: "mte3_ratio";
+        cube_ratio: "cube_ratio";
+        vec_ratio: "vec_ratio";
+        scalar_ratio: "scalar_ratio";
+        fixpipe_ratio: "fixpipe_ratio";
+        l2_bw_pct_of_peak: "l2_bw_pct_of_peak";
+      }>;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"comparison.explain">;
+      reportId: z.ZodString;
+      baselineId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"checks.explain">;
+      reportId: z.ZodString;
+      findingIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"verdict.explain">;
+      reportId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"timeline.measure">;
+      reportId: z.ZodString;
+      fromIndex: z.ZodNumber;
+      toIndex: z.ZodNumber;
+    }, z.core.$strict>], "type">;
+    reportDigest: z.ZodOptional<z.ZodString>;
+    baselineDigest: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type PrepareInteractionRequest = z.infer<typeof prepareInteractionRequestSchema>;
+declare const prepareInteractionResultSchema: z.ZodObject<{
+  naturalLanguage: z.ZodString;
+  eventId: z.ZodUUID;
+}, z.core.$strict>;
+type PrepareInteractionResult = z.infer<typeof prepareInteractionResultSchema>;
+declare const skillCatalogResultSchema: z.ZodObject<{
+  groups: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      en: z.ZodString;
+      zh: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    repository: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+    skills: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      skillName: z.ZodString;
+      path: z.ZodString;
+      sourceId: z.ZodString;
+      name: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodString;
+        zh: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>]>;
+      description: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodString;
+        zh: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  errors: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    message: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SkillCatalogResult = z.infer<typeof skillCatalogResultSchema>;
+interface DeviceInfo {
+  /** Ascend SoC model, e.g. "Ascend 950PR". */
+  readonly soc: string;
+  /** Driver version, e.g. "7.0.t9.0.B849". */
+  readonly driverVersion: string;
+  /** Firmware version line, e.g. "7.0.t9.0.B849 (firmware 1.0)". */
+  readonly firmwareVersion: string;
+  /** Installed CANN packages: directory name and version pair. */
+  readonly cannPackages: readonly {
+    readonly dir: string;
+    readonly version: string;
+  }[];
+  /** Davinci device nodes, e.g. ["/dev/davinci0"]. */
+  readonly devices: readonly string[];
+}
+interface ProbeResult {
+  readonly ok: boolean;
+  readonly message: string;
+  readonly device?: DeviceInfo;
+}
+interface InstallResult {
+  readonly ok: boolean;
+  readonly message: string;
+  /** Full command stdout/stderr tail, shown in the detail view. */
+  readonly log: string;
+}
+interface ProbeRequest {
+  readonly host: string;
+  readonly port: number;
+  readonly username: string;
+  readonly password?: string;
+}
+interface InstallRequest extends ProbeRequest {
+  /** Absolute path of the CANN run/tar package on the remote host. */
+  readonly packagePath: string;
+}
+interface WorkspaceTask extends TaskMetadata {
+  readonly workspaceId: string;
+  readonly mainSessionId?: string;
+}
+interface CreateCANNTaskRequest {
+  readonly workspaceId: string;
+  /** The single primary chat Session for this task. Child-agent Sessions are excluded. */
+  readonly mainSessionId: string;
+  readonly task: TaskMetadata;
+  readonly inputs: Readonly<Record<string, unknown>>;
+  readonly workflow: TaskGraph;
+}
+interface TaskListResult {
+  tasks: WorkspaceTask[];
+  errors: {
+    workspaceId: string;
+    taskId: string;
+    message: string;
+  }[];
+}
+interface CANNTaskTransport {
+  getSessionResources(request: {
+    sessionId: string;
+  }): Promise<RemoteResult<SessionResources>>;
+  setSessionResources(request: SaveSessionResources): Promise<RemoteResult<SessionResources>>;
+  followTasks(signal: AbortSignal): AsyncIterable<TaskListResult>;
+  prepareInteraction(request: PrepareInteractionRequest): Promise<RemoteResult<PrepareInteractionResult>>;
+  listSkills(): Promise<RemoteResult<SkillCatalogResult>>;
+  probe(request: ProbeRequest): Promise<RemoteResult<ProbeResult>>;
+  installCann(request: InstallRequest): Promise<RemoteResult<InstallResult>>;
+  createTask(request: CreateCANNTaskRequest): Promise<RemoteResult<{
+    ok: true;
+    task: WorkspaceTask;
+  }>>;
+  listTasks(): Promise<RemoteResult<TaskListResult>>;
+}
+declare module '@deepseek-ai/dsh-typert-protocol/types' {
+  interface TypertRemoteNamespaceMap {
+    cannWorkbench: CANNTaskTransport;
+  }
+}
+declare const taskEnvironmentSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  host: z.ZodString;
+  port: z.ZodNumber;
+  username: z.ZodString;
+  soc: z.ZodString;
+  connect: z.ZodEnum<{
+    unknown: "unknown";
+    checking: "checking";
+    online: "online";
+    offline: "offline";
+  }>;
+  checkedAt: z.ZodOptional<z.ZodNumber>;
+  device: z.ZodOptional<z.ZodObject<{
+    soc: z.ZodString;
+    driverVersion: z.ZodString;
+    firmwareVersion: z.ZodString;
+    cannPackages: z.ZodArray<z.ZodObject<{
+      dir: z.ZodString;
+      version: z.ZodString;
+    }, z.core.$strip>>;
+    devices: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type TaskEnvironment = z.infer<typeof taskEnvironmentSchema>;
+type EnvironmentReader = () => readonly TaskEnvironment[];
+interface KnowledgeResource {
+  readonly id: string;
+  readonly name: string;
+  readonly transport: 'http' | 'stdio';
+}
+type KnowledgeReader = () => readonly KnowledgeResource[];
+declare class SessionResourcesRepository {
+  private readonly ctx;
+  private readonly root;
+  private readonly environments;
+  private readonly knowledge;
+  private readonly taskForSession;
+  constructor(ctx: Context, root: string, environments: EnvironmentReader, knowledge: KnowledgeReader, taskForSession: (sessionId: string) => Promise<WorkspaceTask | undefined>);
+  private workspace;
+  private saved;
+  private initial;
+  snapshot(sessionId: string): Promise<SessionResources>;
+  save(input: SaveSessionResources): Promise<SessionResources>;
+  effectiveTask(task: WorkspaceTask): Promise<WorkspaceTask>;
+  systemText(sessionId: string): Promise<string>;
+}
+interface DoctorConfig {
+  readonly dataDir?: string;
+  readonly autoUpdate?: boolean;
+  readonly updateIntervalMinutes?: number;
+  readonly repoUrl?: string;
+  readonly branch?: string;
+  readonly packageSkill?: string;
+}
+interface TaskNodeUpdate {
+  readonly nodeId: string;
+  readonly state: TaskGraphNodeState;
+  readonly evidence?: readonly string[];
+  /** One-line stage outcome shown in the sidebar under this node. */
+  readonly summary?: string;
+  /** Machine-readable stage payload keyed by field name; rendered as labeled rows. */
+  readonly structured?: Readonly<Record<string, unknown>>;
+}
+interface TaskProgressUpdate {
+  readonly components?: readonly VisualInput[];
+  readonly componentUpdates?: readonly VisualUpdate[];
+  /** Reply projections must still target the exact snapshot when the repository begins its write. */
+  readonly expectedTask?: Pick<WorkspaceTask, 'id' | 'workspaceId' | 'definitionId' | 'updatedAt'>;
+  readonly nodeUpdates: readonly TaskNodeUpdate[];
+  readonly currentNodeIds: readonly string[];
+  readonly status: WorkspaceTask['status'];
+  readonly blockedReason?: string;
+}
+/** Plugin identity used by the DSH Loader. */
+declare const name = "ascend-workbench";
+/** Required services for the semantic Tool and durable session events. */
+interface Config {
+  readonly diagnosis?: DoctorConfig;
+  /** Absolute documentation roots scanned on each search. */
+  readonly roots: string[];
+  /** Maximum files read per search. */
+  readonly maxFiles: number;
+  /** Maximum bytes read from each file for snippet extraction. */
+  readonly maxFileBytes: number;
+  /**
+   * Managed cannbot-knowledge MCP connections. Each entry drives one
+   * mcp-client row so the page's add/edit/remove reaches the agent tools.
+   * Volatile: edits hot-apply without restarting the panel.
+   */
+  readonly environments?: readonly TaskEnvironment[];
+  readonly environmentCatalogInitialized?: boolean;
+  readonly knowledgeBases: readonly KnowledgeBaseConnection[];
+}
+/** One managed knowledge-base connection mirrored into an mcp-client row. */
+interface KnowledgeBaseConnection {
+  /** Patch entry id; also the mcp-client serverName namespace. */
+  readonly id: string;
+  /** Display name shown in the Workbench page. */
+  readonly name: string;
+  /** Transport kind; stdio rows keep a command, http rows keep a URL. */
+  readonly transport: 'http' | 'stdio';
+  /** MCP endpoint URL for http transport. */
+  readonly url?: string;
+  /** Bearer token for http transport. */
+  readonly token?: string;
+  /** Server command for stdio transport. */
+  readonly command?: string;
+}
+/** Runtime schema for the plugin Config; the volatile wrapper widens the inferred type. */
+declare const Config: z$1<Config>;
+interface WorkbenchOverview {
+  readonly searches: readonly {
+    readonly query: string;
+    readonly resultCount: number;
+    readonly groups: readonly string[];
+  }[];
+  readonly producedFiles: readonly string[];
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+  interface SessionProjectionMap {
+    'cann-workbench/overview': WorkbenchOverview;
+  }
+}
+declare const inject: string[];
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    /** Host owner of the CANN_WORKBENCH Remote namespace. */
+    cannWorkbench: CANNWorkbenchService;
+  }
+}
+/** Host Remote service writing CANN Task metadata and managing environments. */
+declare class CANNWorkbenchService extends TypertRemoteService {
+  static inject: string[];
+  private readonly taskChanges;
+  private readonly tasks;
+  private readonly skillsRoot;
+  private interactions;
+  resourceSelections: SessionResourcesRepository | undefined;
+  getSessionResources(request: {
+    sessionId: string;
+  }): Promise<SessionResources>;
+  setSessionResources(request: SaveSessionResources): Promise<SessionResources>;
+  /** @param ctx - Host context carrying the filesystem and Workspace registry. */
+  constructor(ctx: Context);
+  private sidebarInteractions;
+  /** Prepare a version-checked side selection for exactly one native request identity. */
+  prepareInteraction(request: PrepareInteractionRequest): Promise<PrepareInteractionResult>;
+  /** Add replayable sidebar context while preserving native human and other-plugin messages. */
+  sidebarCompanions(session: import('@deepseek-ai/dsh-session').Session, messages: readonly import('@deepseek-ai/dsh-llm').UserMessage[], signal?: AbortSignal): Promise<import('@deepseek-ai/dsh-llm').UserMessage[]>;
+  /** Read the packaged source registry and scan actual SKILL.md entries. */
+  listSkills(): Promise<SkillCatalogResult>;
+  /** Create one Task directory and persist its identity, inputs, and workflow. */
+  createTask(request: CreateCANNTaskRequest): Promise<{
+    readonly ok: true;
+    readonly task: WorkspaceTask;
+  }>;
+  followTasks(signal: AbortSignal): AsyncIterable<TaskListResult>;
+  listTasks(): Promise<TaskListResult>;
+  /** Return the one task owned by this primary chat Session, if any. */
+  taskForSession(sessionId: string): Promise<WorkspaceTask | undefined>;
+  /** Persist a model-reported workflow transition for its linked primary Session. */
+  updateTaskProgress(sessionId: string, update: TaskProgressUpdate): Promise<WorkspaceTask>;
+  /** Verify credentials and collect NPU/CANN inventory from one remote host. */
+  probe(request: ProbeRequest): Promise<ProbeResult>;
+  /** Install a CANN package from a remote file path (root install via sudo). */
+  installCann(request: InstallRequest): Promise<InstallResult>;
+}
+declare function apply(ctx: Context, config: Config): Promise<void>;
+export { CANNWorkbenchService, Config, type CreateCANNTaskRequest, KnowledgeBaseConnection, WorkbenchOverview, apply, inject, name };