@pstdio/sdk 0.40.0 → 0.41.0

package/dist/{index-BU8PNmuX.d.ts → index-CJNVNXEP.d.ts}

@@ -1,4 +1,4 @@
-import { d as WorkspaceListItem$1, s as Workspace$1 } from "./index-Cbt2YiR-.js";
+import { d as WorkspaceListItem$1, s as Workspace$1 } from "./index-BvsVU-eX.js";
 //#region src/resources/workspace.d.ts
 type Workspace = Workspace$1;
 type WorkspaceListItem = WorkspaceListItem$1;

package/dist/resources/index.js

@@ -6263,6 +6263,7 @@ var agentSkillsLayoutSchema = object({
 });
 var localizableSchema = union([string2(), object({ $l10n: string2(), default: string2().optional() })]);
 var harnessParamBaseSchema = object({
+  control: literal("command").optional(),
   label: localizableSchema.optional(),
   description: localizableSchema.optional(),
   required: boolean2().optional(),
@@ -6597,6 +6598,29 @@ var isNavigationHref = (href) => {
   }
 };
 
+// ../pstdio-api-contracts/src/extension-kernel/source-position.ts
+var isFileSourcePosition = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const position = value;
+  const positive = (number) => typeof number === "number" && Number.isSafeInteger(number) && number > 0;
+  if (!positive(position.line))
+    return false;
+  for (const key of ["column", "endLine", "endColumn"]) {
+    if (position[key] !== undefined && !positive(position[key]))
+      return false;
+  }
+  if (position.endColumn !== undefined && position.endLine === undefined)
+    return false;
+  if (position.endLine !== undefined) {
+    if (position.endLine < position.line)
+      return false;
+    if (position.endLine === position.line && (position.endColumn ?? 1) < (position.column ?? 1))
+      return false;
+  }
+  return true;
+};
+
 // ../pstdio-api-contracts/src/extensions/resource-ref.ts
 var extensionResourceRefSchema = object({
   shorthand: string2().optional(),
@@ -6628,6 +6652,12 @@ var commandTargetSchema = object({
 });
 
 // ../pstdio-api-contracts/src/extensions/navigation-target-metadata.ts
+var sourcePositionSchema = object({
+  line: number2().int().positive(),
+  column: number2().int().positive().optional(),
+  endLine: number2().int().positive().optional(),
+  endColumn: number2().int().positive().optional()
+}).refine(isFileSourcePosition, "Expected ordered source coordinates");
 var sectionSchema = object({
   anchors: array(object({ id: string2(), heading: string2(), occurrence: number2().int().nonnegative().optional() }))
 });
@@ -6637,8 +6667,9 @@ var pageTargetSchema = lazy(() => object({
   resource: extensionResourceRefSchema.optional(),
   open: _enum(["preview", "pin"]).optional(),
   section: sectionSchema.optional(),
+  position: sourcePositionSchema.optional(),
   parent: pageTargetSchema.optional()
-})).meta({ id: "WorkbenchMetadataPageTarget" });
+}).refine((value) => !(value.position && value.section), "Choose a source position or a heading section")).meta({ id: "WorkbenchMetadataPageTarget" });
 var navigationOperationSchema = union([
   pageTargetSchema,
   object({
@@ -6930,6 +6961,105 @@ var extensionControlsRendererRecordSchema = extensionRendererRecordBaseSchema.ex
   defaultValues: controlValuesSchema.optional()
 });
 
+// ../pstdio-api-contracts/src/extension-kernel/types/collection-view.ts
+var optionConditions = ["is-any-of", "is-none-of", "is-empty", "is-not-empty"];
+var VIEW_FILTER_CONDITIONS = {
+  boolean: ["is", "is-not", "is-empty", "is-not-empty"],
+  string: ["contains", "does-not-contain", "is", "is-not", "is-empty", "is-not-empty"],
+  number: ["is", "is-not", "gt", "gte", "lt", "lte", "is-empty", "is-not-empty"],
+  date: ["is", "is-before", "is-after", "is-on-or-before", "is-on-or-after", "is-empty", "is-not-empty"],
+  enum: optionConditions,
+  status: optionConditions,
+  user: optionConditions,
+  "enum-multi": ["has-any-of", "has-all-of", "has-none-of", "is-empty", "is-not-empty"]
+};
+
+// ../pstdio-api-contracts/src/extensions/collection-view.ts
+var VIEW_DAY_PATTERN = /^(\d{4}-\d{2}-\d{2}|today([+-]\d+)?)$/;
+var conditionIds = [...new Set(Object.values(VIEW_FILTER_CONDITIONS).flat())];
+var viewFilterConditionSchema = _enum(conditionIds);
+var viewFilterRuleSchema = object({
+  attributeId: string2().min(1),
+  condition: viewFilterConditionSchema,
+  value: union([boolean2(), string2(), number2(), array(string2())]).optional()
+});
+var advancedFilterGroupSchema = strictObject({
+  conjunction: _enum(["and", "or"]),
+  rules: array(viewFilterRuleSchema)
+});
+var viewFilterGroupSchema = advancedFilterGroupSchema.extend({
+  groups: array(advancedFilterGroupSchema).optional()
+}).refine((filter) => !filter.groups?.length || filter.conjunction === "and", {
+  message: "Normal rules and advanced groups combine using AND"
+});
+var viewSortSchema = object({ attributeId: string2().min(1), direction: _enum(["asc", "desc"]) });
+var viewSortsSchema = array(viewSortSchema).max(1, "A view allows only one sort");
+var viewFilterValueKind = (kind, condition) => {
+  if (condition === "is-empty" || condition === "is-not-empty")
+    return "none";
+  if (condition === "is-any-of" || condition === "is-none-of")
+    return "options";
+  if (kind === "boolean")
+    return "boolean";
+  if (kind === "number")
+    return "number";
+  if (kind === "date")
+    return "day";
+  if (kind === "string")
+    return "text";
+  return "options";
+};
+var valueNeeds = {
+  none: "takes no value",
+  boolean: "needs a boolean",
+  number: "needs a number",
+  day: "needs a day such as 2026-10-02, today, or today-7",
+  text: "needs text",
+  options: "needs a list of option values"
+};
+var valueFits = (value, kind) => {
+  if (value === undefined)
+    return true;
+  if (kind === "none")
+    return false;
+  if (kind === "boolean")
+    return typeof value === "boolean";
+  if (kind === "number")
+    return typeof value === "number" && Number.isFinite(value);
+  if (kind === "day")
+    return typeof value === "string" && VIEW_DAY_PATTERN.test(value);
+  if (kind === "text")
+    return typeof value === "string";
+  return Array.isArray(value);
+};
+var ruleProblem = (rule, fields) => {
+  const filterable = fields.filter((field) => field.filterable);
+  const field = filterable.find((field) => field.id === rule.attributeId);
+  if (!field)
+    return `Invalid filter field "${rule.attributeId}". Valid IDs: ${filterable.map((field) => field.id).join(", ")}`;
+  const conditions = VIEW_FILTER_CONDITIONS[field.kind];
+  const legacyList = ["is-any-of", "is-none-of"].includes(rule.condition) && ["string", "number", "date"].includes(field.kind);
+  if (!conditions.includes(rule.condition) && !legacyList)
+    return `Field "${field.id}" does not accept "${rule.condition}". Valid conditions: ${conditions.join(", ")}`;
+  const valueKind = viewFilterValueKind(field.kind, rule.condition);
+  if (!valueFits(rule.value, valueKind))
+    return `Condition "${rule.condition}" on "${field.id}" ${valueNeeds[valueKind]}`;
+  const options = field.options;
+  const values = Array.isArray(rule.value) ? rule.value : [];
+  const unknown = options ? values.find((value) => !options.some((option) => option.value === value)) : undefined;
+  if (options && unknown !== undefined)
+    return `Invalid filter value "${unknown}" for "${field.id}". Valid values: ${options.map((option) => option.value).join(", ")}`;
+  return;
+};
+var findViewFilterProblem = (filter, fields) => {
+  for (const rule of [...filter.rules, ...(filter.groups ?? []).flatMap((group) => group.rules)]) {
+    const problem = ruleProblem(rule, fields);
+    if (problem)
+      return problem;
+  }
+  return;
+};
+
 // ../pstdio-api-contracts/src/extensions/view-toolbar-action.ts
 var viewToolbarActionSchema = object({
   id: string2(),
@@ -6969,12 +7099,30 @@ var columnRendererSchema = discriminatedUnion("type", [
 var dataTableRendererColumnSchema = object({
   id: string2(),
   label: localizableStringSchema.optional(),
+  type: _enum(["string", "number", "boolean", "date"]).optional(),
+  groupable: boolean2().optional(),
+  filterable: boolean2().optional(),
   description: localizableStringSchema.optional(),
   icon: string2().optional(),
   hidden: boolean2().optional(),
   stat: columnStatSchema.optional(),
   renderer: columnRendererSchema.optional()
 });
+var dataTableRendererSettingsSchema = object({
+  grouping: string2(),
+  rowNumbers: boolean2(),
+  wrapRows: boolean2(),
+  showStats: boolean2(),
+  hiddenColumns: array(string2()),
+  columnOrder: array(string2())
+});
+var dataTableRendererSavedViewSchema = object({
+  id: string2(),
+  title: localizableStringSchema,
+  settings: dataTableRendererSettingsSchema.partial().optional(),
+  filter: viewFilterGroupSchema.optional(),
+  sorts: viewSortsSchema.optional()
+});
 var rowActionSchema = object({
   id: string2(),
   label: localizableStringSchema,
@@ -6998,7 +7146,12 @@ var extensionDataTableRendererRecordSchema = extensionRendererRecordBaseSchema.e
   rowActions: array(rowActionSchema).optional(),
   rowActivationHandlerId: string2().optional(),
   initialPageSize: number2().int().positive().optional(),
-  pageSizeOptions: array(number2().int().positive()).optional()
+  pageSizeOptions: array(number2().int().positive()).optional(),
+  defaultSettings: dataTableRendererSettingsSchema.partial().optional(),
+  defaultFilter: viewFilterGroupSchema.optional(),
+  defaultSorts: viewSortsSchema.optional(),
+  defaultViews: array(dataTableRendererSavedViewSchema).optional(),
+  defaultActiveViewId: string2().optional()
 });
 
 // ../pstdio-api-contracts/src/extensions/kanban-renderer.ts
@@ -7019,6 +7172,7 @@ var kanbanRendererAttributeTypeSchema = discriminatedUnion("kind", [
       id: string2()
     })
   }),
+  object({ kind: literal("boolean"), legacyValues: record(string2(), boolean2()).optional() }),
   object({ kind: literal("string") }),
   object({ kind: literal("date") }),
   object({ kind: literal("number") }),
@@ -7039,21 +7193,18 @@ var kanbanRendererAttributeSchema = object({
   editable: boolean2().optional(),
   display: kanbanRendererAttributeDisplaySchema.optional()
 });
-var kanbanRendererSettingsSchema = object({
+var kanbanViewSettingsSchema = object({
   viewMode: _enum(["board", "list"]),
   columnGrouping: string2(),
   rowGrouping: string2(),
-  ordering: object({
-    attributeId: string2(),
-    direction: _enum(["asc", "desc"])
-  }),
   displayProperties: array(string2())
 });
 var kanbanRendererSavedViewSchema = object({
   id: string2(),
   title: localizableStringSchema,
-  settings: kanbanRendererSettingsSchema,
-  filters: record(string2(), array(string2())),
+  settings: kanbanViewSettingsSchema,
+  filter: viewFilterGroupSchema,
+  sorts: viewSortsSchema,
   isDefault: boolean2().optional()
 });
 var extensionKanbanRendererCreateRowSchema = object({
@@ -7093,8 +7244,9 @@ var extensionKanbanRendererRecordSchema = extensionRendererRecordBaseSchema.exte
   createRow: extensionKanbanRendererCreateRowSchema.optional(),
   rowActions: array(extensionKanbanRendererRowActionSchema).optional(),
   rowActivationHandlerId: string2().optional(),
-  defaultSettings: kanbanRendererSettingsSchema.partial().optional(),
-  defaultFilters: record(string2(), array(string2())).optional(),
+  defaultSettings: kanbanViewSettingsSchema.partial().optional(),
+  defaultFilter: viewFilterGroupSchema.optional(),
+  defaultSorts: viewSortsSchema.optional(),
   defaultViews: array(kanbanRendererSavedViewSchema).optional(),
   defaultActiveViewId: string2().optional(),
   hideToolbar: boolean2().optional()
@@ -7190,6 +7342,7 @@ var workbenchExtensionPageRecordSchema = object({
   title: localizableStringSchema,
   icon: string2().optional(),
   path: string2(),
+  document: object({ metadataKey: string2().refine((key) => key.trim().length > 0) }).optional(),
   mode: modeRefSchema,
   parent: pageRefSchema.optional(),
   resource: resourceConstraintSchema.optional(),
@@ -7212,6 +7365,12 @@ var extensionSettingsPanelRecordSchema = object({
   section: string2().optional(),
   webview: extensionWebviewContributionSchema
 });
+var extensionSettingOptionSourceSchema = object({
+  commandId: string2(),
+  valueField: string2(),
+  labelField: string2(),
+  params: record(string2(), unknown()).optional()
+});
 var extensionSettingDefinitionRecordSchema = object({
   key: string2(),
   extensionId: string2(),
@@ -7219,6 +7378,7 @@ var extensionSettingDefinitionRecordSchema = object({
   scope: extensionSettingScopeSchema,
   default: unknown().optional(),
   enum: array(unknown()).optional(),
+  options: extensionSettingOptionSourceSchema.optional(),
   title: localizableStringSchema.optional(),
   description: localizableStringSchema.optional()
 });
@@ -7263,8 +7423,7 @@ var rendererBaseOmissions = {
   id: true,
   extensionId: true,
   title: true,
-  icon: true,
-  resourceKind: true
+  icon: true
 };
 var commandActionSchema = object({
   id: string2(),
@@ -7535,6 +7694,15 @@ var listExtensionAppearanceResponseSchema = object({
   translations: array(extensionTranslationRecordSchema),
   diagnostics: workbenchExtensionMetadataSchema.shape.diagnostics
 });
+// ../pstdio-api-contracts/src/extension-kernel/types/data-table-renderer.ts
+var DEFAULT_DATA_TABLE_SETTINGS = {
+  grouping: "none",
+  rowNumbers: true,
+  wrapRows: false,
+  showStats: true,
+  hiddenColumns: [],
+  columnOrder: []
+};
 // ../pstdio-api-contracts/src/extensions/install.ts
 var enableInstalledExtensionRequestSchema = object({
   displayName: string2(),
@@ -7683,33 +7851,38 @@ var listAutomationRunEventsResponseSchema = object({ events: array(automationRun
 var boardFieldSchema = object({
   id: string2(),
   label: string2(),
-  kind: _enum(["enum", "enum-multi", "status", "string", "date", "number", "user"]),
+  kind: _enum(["enum", "enum-multi", "status", "string", "date", "number", "boolean", "user"]),
+  conditions: array(viewFilterConditionSchema),
   filterable: boolean2(),
   groupable: boolean2(),
   sortable: boolean2(),
   displayable: boolean2(),
+  legacyValues: record(string2(), boolean2()).optional(),
   options: array(object({ value: string2(), label: string2() })).optional()
 });
 var boardSummarySchema = object({
   id: string2(),
   title: string2(),
-  extensionId: string2(),
+  kind: _enum(["kanban", "dataTable"]),
+  extensionId: string2().nullable(),
   fields: array(boardFieldSchema)
 });
-var boardFiltersSchema = record(string2(), array(string2()));
+var boardViewSettingsSchema = union([kanbanViewSettingsSchema, dataTableRendererSettingsSchema]);
 var boardViewSchema = object({
   id: string2(),
   boardId: string2(),
   title: string2(),
-  settings: kanbanRendererSettingsSchema,
-  filters: boardFiltersSchema,
+  settings: boardViewSettingsSchema,
+  filter: viewFilterGroupSchema,
+  sorts: viewSortsSchema,
   builtIn: boolean2()
 });
 var boardViewsSchema = object({ views: array(boardViewSchema), defaultViewId: string2() });
 var boardViewUpdateSchema = object({
   title: string2().trim().min(1).optional(),
-  settings: kanbanRendererSettingsSchema.partial().optional(),
-  filters: boardFiltersSchema.optional()
+  settings: union([kanbanViewSettingsSchema.partial().strict(), dataTableRendererSettingsSchema.partial().strict()]).optional(),
+  filter: viewFilterGroupSchema.optional(),
+  sorts: viewSortsSchema.optional()
 }).strict();
 var boardViewCreateSchema = boardViewUpdateSchema.extend({
   title: string2().trim().min(1),
@@ -7718,6 +7891,24 @@ var boardViewCreateSchema = boardViewUpdateSchema.extend({
 // ../pstdio-api-contracts/src/extension-kernel/api-versions.ts
 var numericIdentifier = "(?:0|[1-9]\\d*)";
 var caretTerm = new RegExp(`^\\^(${numericIdentifier}\\.${numericIdentifier}\\.${numericIdentifier})$`);
+// ../pstdio-api-contracts/src/extension-kernel/boolean-view-filter.ts
+var normalizeBooleanViewRule = (rule, type) => {
+  const mapping = type.kind === "boolean" ? type.legacyValues : undefined;
+  if (!mapping || !Array.isArray(rule.value) || rule.value.length === 0)
+    return rule;
+  if (rule.condition !== "is-any-of" && rule.condition !== "is-none-of")
+    return rule;
+  if (rule.value.some((value) => !Object.hasOwn(mapping, value)))
+    return rule;
+  const values = new Set(rule.value.map((value) => mapping[value]));
+  if (values.size === 2)
+    return { attributeId: rule.attributeId, condition: rule.condition === "is-any-of" ? "is-not-empty" : "is-empty" };
+  return {
+    attributeId: rule.attributeId,
+    condition: rule.condition === "is-any-of" ? "is" : "is-not",
+    value: [...values][0]
+  };
+};
 // ../pstdio-api-contracts/src/extension-kernel/builtin-refs.ts
 var hostRef = (kind, id) => ({ extensionId: "pstdio", kind, id });
 var workbenchModes = {
@@ -7809,6 +8000,24 @@ var workbenchSlots = {
 var localContributionIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$/;
 var isValidLocalContributionId = (id) => localContributionIdPattern.test(id);
 var localContributionIdGrammar = 'lowercase kebab-case segments separated by dots, such as "ticket-status.create"';
+// ../pstdio-api-contracts/src/extension-kernel/data-table-values.ts
+var resolveDataTableComparableValue = (value, renderer) => {
+  if (typeof value !== "object" || value === null)
+    return value;
+  if ("display" in value)
+    return "sortValue" in value ? value.sortValue : undefined;
+  if (renderer?.type === "diff" && "additions" in value && "deletions" in value && typeof value.additions === "number" && typeof value.deletions === "number")
+    return value.additions + value.deletions;
+  return value;
+};
+var resolveDataTableFieldKind = (values, column = {}) => {
+  if (column.type)
+    return column.type;
+  if (column.renderer?.type === "date")
+    return "date";
+  const comparable = values.map((value) => resolveDataTableComparableValue(value, column.renderer)).filter((value) => value !== null && value !== undefined);
+  return comparable.length > 0 && comparable.every((value) => typeof value === "number") ? "number" : "string";
+};
 // ../pstdio-api-contracts/src/extension-kernel/refs.ts
 var createCommandRef = (input) => ({ ...input, kind: "command" });
 var commandRef = Object.assign(createCommandRef, {
@@ -7898,6 +8107,8 @@ var isPageTarget = (value, ancestors = new Set) => {
     return false;
   if (value.section !== undefined && !isRecord(value.section))
     return false;
+  if (value.position !== undefined && (!isFileSourcePosition(value.position) || value.section !== undefined))
+    return false;
   if (!isOpenIntent(value.open))
     return false;
   if (value.parent === undefined)
@@ -7971,7 +8182,7 @@ var packageAsset = (path, baseUrl) => ({
   baseUrl
 });
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
-var EXTENSION_API_VERSION = "0.1.1";
+var EXTENSION_API_VERSION = "0.1.2";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
 var WEBVIEW_HOST_CAPABILITY_VERSION = 1;
 var WEBVIEW_DECLARABLE_CAPABILITIES = [
@@ -8014,6 +8225,66 @@ var fileRecordSchema = object({
   created_at: string2(),
   updated_at: string2()
 });
+// ../pstdio-api-contracts/src/harness-commands.ts
+var harnessCommandSchema = object({
+  name: string2(),
+  description: string2(),
+  argumentHelp: string2().optional(),
+  composer: object({
+    label: string2(),
+    modeId: string2().optional(),
+    reservedArguments: array(string2()).optional()
+  }).optional(),
+  disabledReason: string2().optional()
+});
+var harnessModeActionSchema = object({
+  id: string2(),
+  label: string2(),
+  icon: string2().optional(),
+  argument: object({ label: string2(), value: string2().optional() }).optional()
+});
+var harnessModeSchema = object({
+  id: string2(),
+  label: string2(),
+  description: string2(),
+  state: string2(),
+  indicator: object({ label: string2(), tone: _enum(["neutral", "info", "success", "warning", "error"]) }).optional(),
+  tagText: string2().optional(),
+  closeActionId: string2().optional(),
+  confirmation: object({
+    id: string2(),
+    title: string2(),
+    actionId: string2(),
+    cancelLabel: string2().optional(),
+    model: string2().optional()
+  }).optional(),
+  actions: array(harnessModeActionSchema)
+});
+var harnessCommandStateSchema = object({
+  commands: array(harnessCommandSchema),
+  modes: array(harnessModeSchema),
+  slashCommands: boolean2()
+});
+var harnessOperationSchema = discriminatedUnion("kind", [
+  object({ kind: literal("command"), text: string2().min(1) }).strict(),
+  object({
+    kind: literal("mode-action"),
+    modeId: string2(),
+    actionId: string2(),
+    argument: string2().optional()
+  }).strict()
+]);
+var draftHarnessCommandInputSchema = object({
+  project_id: string2().min(1),
+  agent: string2().min(1),
+  workspace_id: string2().optional(),
+  model: string2().optional(),
+  params: record(string2(), union([string2(), boolean2()])).optional()
+}).strict();
+var harnessOperationResponseSchema = object({
+  status: _enum(["completed", "started"]),
+  message: string2().optional()
+});
 // ../pstdio-api-contracts/src/history-turn-evidence.ts
 var historyTurnEvidence = (known, native, prompt, body) => {
   const signatures = (turn) => JSON.stringify([prompt(turn), body(turn)]);
@@ -8270,6 +8541,35 @@ var updateProjectInputSchema = object({
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
 });
+// ../pstdio-api-contracts/src/resource-anchors.ts
+var resourceLinkRefSchema = extensionResourceRefSchema.extend({
+  type: string2().min(1),
+  id: string2().min(1),
+  projectId: string2().min(1).optional(),
+  extensionId: string2().min(1).optional()
+});
+var resourceAnchorSchema = resourceLinkRefSchema.extend({
+  role: _enum(["primary", "context", "source", "result"]).optional()
+});
+var addResourceAnchorsSchema = object({
+  resource: resourceLinkRefSchema,
+  anchors: array(resourceAnchorSchema).max(100)
+});
+var removeResourceAnchorsSchema = object({
+  resource: resourceLinkRefSchema,
+  refs: array(resourceLinkRefSchema).max(100)
+});
+var resourceAnchorQuerySchema = object({
+  resource: resourceLinkRefSchema,
+  direction: _enum(["outgoing", "incoming", "both"]).optional(),
+  role: _enum(["primary", "context", "source", "result"]).optional(),
+  cursor: string2().optional(),
+  limit: number2().int().min(1).max(100).optional()
+});
+var resourceAnchorPageSchema = object({
+  items: array(object({ source: resourceLinkRefSchema, target: resourceAnchorSchema })),
+  nextCursor: string2().optional()
+});
 // ../pstdio-api-contracts/src/session-attachment-types.ts
 var sessionAttachmentMimeTypesByExtension = {
   c: "text/plain",
@@ -8445,6 +8745,9 @@ var sessionSchema = object({
 var sessionAttachmentRefSchema = object({
   file_id: string2().min(1)
 });
+var createSessionResponseSchema = sessionSchema.extend({
+  operation_result: harnessOperationResponseSchema.optional()
+});
 var sessionAttachmentSchema = object({
   file_id: string2(),
   name: string2(),
@@ -8459,6 +8762,7 @@ var createSessionInputSchema = object({
   project_id: string2().min(1),
   title: string2().min(1),
   prompt: string2().min(1).optional(),
+  operation: harnessOperationSchema.optional(),
   agent: string2().min(1).optional(),
   workspace_id: string2().optional(),
   anchors: array(extensionResourceRefSchema).optional(),
@@ -8531,8 +8835,7 @@ var skillSourceKindSchema = _enum(["project", "extension"]);
 var skillAgentInstallationSchema = object({
   agent_id: string2(),
   agent_name: string2(),
-  installed_version: string2().nullable(),
-  outdated: boolean2()
+  installed_version: string2().nullable()
 });
 var skillSchema = object({
   id: string2(),
@@ -8556,7 +8859,6 @@ var skillSchema = object({
 });
 var skillWithContentSchema = skillSchema.extend({
   installed_agents: array(string2()),
-  outdated_agents: array(string2()),
   agent_installations: array(skillAgentInstallationSchema)
 });
 var updateSkillInputSchema = object({

package/dist/resources.d.ts

@@ -1,4 +1,4 @@
-import { Fu as SkillFile, Iu as SkillWithContent, Jd as AgentAvailabilityType, Ku as Session, Pu as Skill, Qd as harnessLocalId, Qu as SessionStatus, Xd as AgentModel, Yd as AgentInfo, Zd as AgentSkillsLayout, b as FileRecord, m as Settings, v as Project } from "./index-Cbt2YiR-.js";
-import { n as WorkspaceListItem, t as Workspace } from "./index-BU8PNmuX.js";
+import { Af as AgentAvailabilityType, Mf as AgentModel, Nf as AgentSkillsLayout, Pf as harnessLocalId, Xu as SkillFile, Yu as Skill, Zu as SkillWithContent, b as FileRecord, cd as Session, jf as AgentInfo, m as Settings, md as SessionStatus, v as Project } from "./index-BvsVU-eX.js";
+import { n as WorkspaceListItem, t as Workspace } from "./index-CJNVNXEP.js";
 export { type AgentAvailabilityType, type AgentInfo, type AgentModel, type AgentSkillsLayout, type FileRecord, type Project, type Session, type SessionStatus, type Settings, type Skill, type SkillFile, type SkillWithContent, type Workspace, type WorkspaceListItem, harnessLocalId };
 export {};

package/dist/sessions-BtOnRpZy.d.ts

@@ -0,0 +1,2 @@
+import "./index-BvsVU-eX.js";
+export {};

package/dist/skills-BtOnRpZy.d.ts

@@ -0,0 +1,2 @@
+import "./index-BvsVU-eX.js";
+export {};

package/dist/testing/index.js

@@ -1,6 +1,57 @@
+// src/testing/memory-resource-links.ts
+var createMemoryResourceLinks = (input) => {
+  const canonical = (ref) => {
+    if (ref.projectId && ref.projectId !== input.projectId)
+      throw new Error("Resource belongs to another project.");
+    return { ...ref, projectId: input.projectId, extensionId: ref.extensionId ?? input.extensionId };
+  };
+  const identity = (ref) => JSON.stringify([ref.projectId, ref.extensionId, ref.type, ref.id]);
+  const pair = (source, target) => JSON.stringify([identity(source), identity(target)]);
+  return {
+    addAnchors: async (resource, anchors) => {
+      const source = canonical(resource);
+      const targets = anchors.map((anchor) => ({ ...canonical(anchor), role: anchor.role ?? "context" }));
+      for (const target of targets)
+        input.edges.set(pair(source, target), { source, target });
+    },
+    removeAnchors: async (resource, refs) => {
+      const source = canonical(resource);
+      const targets = refs.map(canonical);
+      for (const target of targets)
+        input.edges.delete(pair(source, target));
+    },
+    listAnchors: async (query) => {
+      const ref = identity(canonical(query.resource));
+      const direction = query.direction ?? "outgoing";
+      const limit = query.limit ?? 50;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("Limit must be between 1 and 100.");
+      const rows = [...input.edges.entries()].filter(([key, edge]) => {
+        const outgoing = identity(edge.source) === ref && direction !== "incoming";
+        const incoming = identity(edge.target) === ref && direction !== "outgoing";
+        return (outgoing || incoming) && (!query.role || edge.target.role === query.role) && (!query.cursor || key > query.cursor);
+      }).sort(([a], [b]) => {
+        if (a === b)
+          return 0;
+        return a < b ? -1 : 1;
+      });
+      return {
+        items: rows.slice(0, limit).map(([, edge]) => edge),
+        ...rows.length > limit ? { nextCursor: rows[limit - 1][0] } : {}
+      };
+    },
+    removed: async (resource) => {
+      const ref = identity(canonical(resource));
+      for (const [key, edge] of input.edges)
+        if (identity(edge.source) === ref || identity(edge.target) === ref)
+          input.edges.delete(key);
+    }
+  };
+};
+
 // src/testing/memory-resources.ts
-var createMemoryResources = (prefixes, sequences = new Map) => ({
-  removed: async () => {},
+var createMemoryResources = (prefixes, sequences = new Map, links = createMemoryResourceLinks({ projectId: "proj-1", extensionId: "test.extension", edges: new Map })) => ({
+  ...links,
   allocate: async ({ kind }) => {
     const prefix = prefixes[kind];
     if (!prefix)
@@ -12,6 +63,7 @@ var createMemoryResources = (prefixes, sequences = new Map) => ({
 });
 
 // src/testing/command-context.ts
+var linksByStorage = new WeakMap;
 var sequencesByStorage = new WeakMap;
 var paramsByContext = new WeakMap;
 var makeCommandContext = (input) => {
@@ -21,7 +73,12 @@ var makeCommandContext = (input) => {
     sequences = new Map;
     sequencesByStorage.set(storage, sequences);
   }
-  const resources = createMemoryResources(input.resourcePrefixes ?? {}, sequences);
+  let edges = linksByStorage.get(storage);
+  if (!edges) {
+    edges = new Map;
+    linksByStorage.set(storage, edges);
+  }
+  const resources = createMemoryResources(input.resourcePrefixes ?? {}, sequences, createMemoryResourceLinks({ projectId, extensionId: overrides?.extensionId ?? "test.extension", edges }));
   const context = {
     extensionId: "test.extension",
     name: "test-extension",