@pstdio/sdk 0.44.0-nightly.20261018030230 → 0.44.0

package/dist/api/index.js

@@ -6256,6 +6256,7 @@ var activityEventSchema = object({
   created_at: string2()
 });
 var listActivityInputSchema = object({
+  eventType: string2().optional(),
   event_type: string2().optional(),
   from: string2().optional(),
   to: string2().optional(),
@@ -6269,6 +6270,21 @@ var listActivityResponseSchema = object({
   events: array(activityEventSchema),
   next_cursor: string2().nullable()
 });
+var activityEntrySchema = object({
+  id: string2(),
+  projectId: string2(),
+  resourceType: string2(),
+  resourceId: string2(),
+  sourceExtensionId: string2().nullable(),
+  eventType: string2(),
+  actorType: activityActorTypeSchema,
+  actorId: string2().nullable(),
+  source: activitySourceSchema,
+  summary: string2(),
+  payloadJson: record(string2(), unknown()),
+  createdAt: string2()
+});
+var activityPageSchema = object({ items: array(activityEntrySchema), nextCursor: string2().nullable() });
 // ../pstdio-api-contracts/src/harness.ts
 var AGENT_CAPABILITIES = [
   "SessionFork",
@@ -6324,6 +6340,9 @@ var agentModelSchema = object({
   paramOverrides: record(string2(), harnessParamDescriptorSchema.nullable()).optional()
 });
 var harnessLocalId = (id) => id.slice(id.lastIndexOf(".") + 1);
+var agentDetailsSchema = agentInfoSchema.extend({
+  skills: agentSkillsLayoutSchema.extend({ globalDir: string2() }).optional()
+});
 // ../pstdio-sync-contracts/src/compatibility.ts
 var peerSchema = strictObject({
   release: string2().min(1),
@@ -6528,7 +6547,8 @@ var receiptSchema = strictObject({
   status: _enum(["accepted", "conflict", "pending"]),
   reason: string2().optional(),
   checkpoint: checkpointSchema.nullable(),
-  conflictId: identitySchema.optional()
+  conflictId: identitySchema.optional(),
+  recoveryProof: fingerprintSchema.optional()
 }).superRefine((receipt, ctx) => {
   const identityMatches = receipt.operationId === receipt.mutation.operationId && receipt.fingerprint === receipt.mutation.fingerprint;
   const accepted = receipt.status === "accepted";
@@ -6576,6 +6596,44 @@ var replaySchema = strictObject({
       message: "Replay must contain contiguous complete accepted groups in one scope and epoch"
     });
 });
+// ../pstdio-sync-contracts/src/transport.ts
+var relayOperationSchema = _enum([
+  "initialize",
+  "snapshot",
+  "replay",
+  "submit",
+  "recover",
+  "changes",
+  "assets/begin",
+  "assets/part",
+  "assets/finish",
+  "assets/cancel",
+  "assets/read"
+]);
+var relayRecoverySchema = strictObject({ mutation: mutationSchema, proof: fingerprintSchema });
+var targetSchema = strictObject({ workbenchId: identitySchema, extensionId: identitySchema });
+var relayReplayResultSchema = discriminatedUnion("status", [
+  strictObject({ status: literal("replay"), batch: replaySchema }),
+  strictObject({ status: literal("snapshot-required"), checkpoint: checkpointSchema })
+]);
+var byteLengthSchema = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var relayAssetBeginSchema = strictObject({ uploadId: identitySchema, asset: assetSchema });
+var relayAssetUploadSchema = strictObject({ uploadId: identitySchema });
+var relayAssetPartSchema = strictObject({
+  uploadId: identitySchema,
+  number: number2().int().min(1).max(1e4),
+  sha256: fingerprintSchema,
+  byteLength: byteLengthSchema
+});
+var relayAssetReadSchema = strictObject({ asset: assetSchema, offset: byteLengthSchema }).refine(({ asset, offset }) => offset <= asset.byteLength, "Offset exceeds the asset");
+var relayAssetStatusSchema = strictObject({
+  asset: assetSchema,
+  partSize: number2().int().positive(),
+  completed: boolean2(),
+  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema }))
+});
+var relayEventSchema = strictObject({ protocolVersion: literal(1), type: _enum(["ready", "changed"]) });
+var relayInitializeSchema = strictObject({ publishedRevision: identitySchema });
 // ../pstdio-api-contracts/src/assets.ts
 var assetReferenceSchema = assetSchema;
 var assetOwnerSchema = strictObject({ workbenchId: identitySchema, extensionId: identitySchema });
@@ -6763,6 +6821,7 @@ var workbenchAttachmentTargetSchema = union([
 var workbenchSettingsScopeSchema = _enum(workbenchSettingsScopes);
 
 // ../pstdio-api-contracts/src/extensions/commands.ts
+var commandParamDescriptorSchema = object({ type: string2(), description: localizableStringSchema.optional() }).catchall(unknown());
 var extensionCommandRecordSchema = object({
   id: string2(),
   extensionId: string2(),
@@ -6777,9 +6836,9 @@ var extensionCommandRecordSchema = object({
     object({ kind: literal("rename"), resourceType: string2(), idParam: string2(), labelParam: string2() }),
     object({ kind: literal("remove"), resourceType: string2(), idParam: string2() })
   ]).optional(),
-  params: record(string2(), object({ type: string2() }).catchall(unknown())).optional()
+  params: record(string2(), commandParamDescriptorSchema).optional()
 });
-var extensionParamObjectSchema = record(string2(), object({ type: string2() }).catchall(unknown()));
+var extensionParamObjectSchema = record(string2(), commandParamDescriptorSchema);
 var extensionMiddlewareRecordSchema = object({
   id: string2(),
   extensionId: string2(),
@@ -7101,6 +7160,57 @@ var navigationTargetSchema = union([
   object({ kind: literal("compound"), targets: array(navigationOperationSchema).min(1) })
 ]);
 
+// ../pstdio-api-contracts/src/extensions/command-outcome.ts
+var notice = object({
+  type: _enum(["info", "success", "warning", "error"]),
+  title: string2().optional(),
+  message: string2(),
+  metadata: serializableJsonObjectSchema.optional()
+});
+var diagnostic = object({
+  code: string2(),
+  message: string2(),
+  severity: _enum(["info", "warning", "error"]),
+  extensionId: string2().optional(),
+  commandId: string2().optional(),
+  metadata: serializableJsonObjectSchema.optional()
+});
+var createCommandOutcomeSchema = (jsonValue) => {
+  const error = object({
+    name: string2().optional(),
+    message: string2(),
+    stack: string2().optional(),
+    cause: jsonValue.optional()
+  });
+  const annotations = {
+    notices: array(notice).optional(),
+    diagnostics: array(diagnostic).optional()
+  };
+  const failure = {
+    ...annotations,
+    ok: literal(false),
+    code: string2().optional(),
+    reason: string2(),
+    data: serializableJsonObjectSchema.optional(),
+    cause: jsonValue.optional(),
+    error: error.optional()
+  };
+  const navigation = navigationTargetSchema;
+  const outcome = discriminatedUnion("status", [
+    object({
+      ...annotations,
+      ok: literal(true),
+      status: literal("success"),
+      value: unknown().optional(),
+      navigationRequests: array(navigation).optional()
+    }).transform((outcome) => ({ ...outcome, value: outcome.value })),
+    object({ ...failure, status: literal("rejected") }),
+    object({ ...failure, status: literal("error") })
+  ]);
+  return outcome;
+};
+var validatedCommandOutcomeSchema = createCommandOutcomeSchema(json());
+
 // ../pstdio-api-contracts/src/extensions/execute.ts
 var extensionSlotInvocationSchema = object({
   id: string2(),
@@ -7144,25 +7254,6 @@ var dispatchExtensionEventBodySchema = object({
   eventId: string2().min(1),
   payload: jsonObjectSchema
 }).strict();
-var serializedErrorSchema = object({
-  name: string2().optional(),
-  message: string2(),
-  stack: string2().optional()
-});
-var commandNoticeSchema = object({
-  type: _enum(["info", "success", "warning", "error"]),
-  title: string2().optional(),
-  message: string2(),
-  metadata: jsonObjectSchema.optional()
-});
-var commandDiagnosticSchema = object({
-  code: string2(),
-  message: string2(),
-  severity: _enum(["info", "warning", "error"]),
-  extensionId: string2().optional(),
-  commandId: string2().optional(),
-  metadata: jsonObjectSchema.optional()
-});
 var responseNavigationTargetSchema = navigationTargetSchema;
 var commandOutcomeSchema = object({
   ok: boolean2(),
@@ -7172,16 +7263,33 @@ var commandOutcomeSchema = object({
   code: string2().optional(),
   reason: string2().optional(),
   data: jsonObjectSchema.optional(),
-  error: serializedErrorSchema.optional(),
-  notices: array(commandNoticeSchema).optional(),
-  diagnostics: array(commandDiagnosticSchema).optional()
+  error: object({ name: string2().optional(), message: string2(), stack: string2().optional() }).optional(),
+  notices: array(object({
+    type: _enum(["info", "success", "warning", "error"]),
+    title: string2().optional(),
+    message: string2(),
+    metadata: jsonObjectSchema.optional()
+  })).optional(),
+  diagnostics: array(object({
+    code: string2(),
+    message: string2(),
+    severity: _enum(["info", "warning", "error"]),
+    extensionId: string2().optional(),
+    commandId: string2().optional(),
+    metadata: jsonObjectSchema.optional()
+  })).optional()
 });
-var commandExecuteResponseSchema = object({
+var responseFields = {
   commandId: string2(),
   extensionId: string2(),
-  eventIds: array(string2()).optional(),
+  eventIds: array(string2()).optional()
+};
+var commandExecuteResponseSchema = object({
+  ...responseFields,
   outcome: commandOutcomeSchema
 });
+var createCommandExecutionResultSchema = (jsonValue) => object({ ...responseFields, outcome: createCommandOutcomeSchema(jsonValue) });
+var commandExecutionResultSchema = createCommandExecutionResultSchema(json());
 
 // ../pstdio-api-contracts/src/extensions/control-declarations.ts
 var base = { id: string2(), name: string2(), description: string2().optional(), readOnly: boolean2().optional() };
@@ -7587,14 +7695,6 @@ var kanbanRendererEnumOptionSchema = object({
 var kanbanRendererAttributeTypeSchema = discriminatedUnion("kind", [
   object({ kind: literal("enum"), options: array(kanbanRendererEnumOptionSchema) }),
   object({ kind: literal("enum-multi"), options: array(kanbanRendererEnumOptionSchema) }),
-  object({
-    kind: literal("status"),
-    statuses: object({
-      extensionId: string2().optional(),
-      kind: literal("status"),
-      id: string2()
-    })
-  }),
   object({ kind: literal("boolean"), legacyValues: record(string2(), boolean2()).optional() }),
   object({ kind: literal("string") }),
   object({ kind: literal("date") }),
@@ -7627,8 +7727,7 @@ var kanbanRendererSavedViewSchema = object({
   title: localizableStringSchema,
   settings: kanbanViewSettingsSchema,
   filter: viewFilterGroupSchema,
-  sorts: viewSortsSchema,
-  isDefault: boolean2().optional()
+  sorts: viewSortsSchema
 });
 var extensionKanbanRendererCreateRowSchema = object({
   commandId: string2(),
@@ -7662,7 +7761,6 @@ var extensionKanbanRendererRecordSchema = extensionRendererRecordBaseSchema.exte
   attributes: array(kanbanRendererAttributeSchema).optional(),
   queryHandlerId: string2(),
   attributeChangeHandlerId: string2().optional(),
-  reorderHandlerId: string2().optional(),
   moveHandlerId: string2().optional(),
   schemaRefreshEventIds: array(string2()).optional(),
   columnActionHandlerId: string2().optional(),
@@ -7836,7 +7934,6 @@ var modeRefSchema2 = contributionRefSchema2("mode");
 var pageRefSchema2 = contributionRefSchema2("page");
 var resourceKindRefSchema2 = contributionRefSchema2("resource-kind");
 var settingsSectionRefSchema = contributionRefSchema2("settings-section");
-var statusRefSchema = contributionRefSchema2("status");
 var viewRefSchema2 = contributionRefSchema2("view");
 var normalizedWhenSchema = object({
   mode: union([modeRefSchema2, array(modeRefSchema2)]).optional(),
@@ -7965,6 +8062,7 @@ var workbenchExtensionResourceKindRecordSchema = object({
   icon: string2().optional(),
   resolveCommand: string2().optional(),
   resolveManyCommand: string2().optional(),
+  relatedOpeningsCommand: string2().optional(),
   paths: array(object({ prefix: string2(), resolveCommand: string2() })).optional(),
   menuSlots: array(object({
     id: string2(),
@@ -7989,15 +8087,6 @@ var workbenchExtensionStatusBarItemRecordSchema = object({
   order: number2().optional(),
   when: normalizedWhenSchema.optional()
 });
-var workbenchExtensionStatusRecordSchema = object({
-  id: string2(),
-  localId: string2(),
-  extensionId: string2(),
-  title: localizableStringSchema,
-  actions: array(object({ id: string2(), label: localizableStringSchema, icon: string2().optional() })).optional(),
-  queryHandlerId: string2(),
-  saveHandlerId: string2().optional()
-});
 var workbenchExtensionMetadataSchema = object({
   extensions: array(extensionRecordSchema),
   commands: array(extensionCommandRecordSchema),
@@ -8013,7 +8102,6 @@ var workbenchExtensionMetadataSchema = object({
   navigationItems: array(workbenchExtensionNavigationItemRecordSchema),
   navigationTrees: array(workbenchExtensionNavigationTreeRecordSchema),
   statusBarItems: array(workbenchExtensionStatusBarItemRecordSchema),
-  statuses: array(workbenchExtensionStatusRecordSchema),
   activityItems: array(object({
     id: string2(),
     extensionId: string2(),
@@ -8087,7 +8175,6 @@ var checkWorkbenchMetadataSchema = workbenchExtensionMetadataSchema.pick({
   navigationItems: true,
   navigationTrees: true,
   statusBarItems: true,
-  statuses: true,
   activityItems: true,
   settingsSections: true,
   settingsPanels: true,
@@ -8270,6 +8357,13 @@ var extensionDiagnosticsResponseSchema = object({
     check: extensionsCheckResponseSchema
   }))
 });
+// ../pstdio-api-contracts/src/extensions/related-resource-opening.ts
+var relatedResourceOpeningSchema = object({
+  resource: extensionResourceRefSchema,
+  autoOpen: boolean2().optional(),
+  region: _enum(extensionPanelRegions),
+  open: _enum(["preview", "pin"]).optional()
+});
 // ../pstdio-api-contracts/src/automation.ts
 var automationRunStatusSchema = _enum(["queued", "running", "succeeded", "failed", "cancelled", "rejected"]);
 var issueAutomationTokenInputSchema = object({
@@ -8422,6 +8516,28 @@ var updateProjectInputSchema = object({
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
 });
+var projectDetailsSchema = object({
+  id: string2(),
+  name: string2(),
+  shorthand: string2(),
+  defaultAgentId: string2().nullable(),
+  defaultAgentModel: string2().nullable(),
+  startupScript: string2().nullable(),
+  createdAt: string2(),
+  updatedAt: string2(),
+  deletedAt: string2().nullable(),
+  extensionWarnings: array(extensionSetupWarningSchema).optional()
+});
+var initialWorkspaceRequestSchema = object({
+  providerId: string2().min(1),
+  params: serializableJsonObjectSchema.default({})
+});
+var projectCreateRequestSchema = createProjectInputSchema.omit({ initial_workspace: true }).extend({ initialWorkspace: initialWorkspaceRequestSchema });
+var projectUpdateRequestSchema = object({
+  name: string2().trim().min(1).optional(),
+  defaultAgentId: string2().min(1).nullable().optional(),
+  defaultAgentModel: string2().min(1).nullable().optional()
+}).strict().refine((value) => Object.keys(value).length > 0, { message: "At least one field must be provided" });
 
 // ../pstdio-api-contracts/src/workspaces.ts
 var workspaceProviderRefShape = {
@@ -8446,7 +8562,6 @@ var workspaceCapabilitiesSchema = object({
   diff: boolean2(),
   merge: boolean2(),
   rebase: boolean2(),
-  archive: boolean2(),
   delete: boolean2()
 });
 var workspaceProviderErrorSchema = object({
@@ -8455,6 +8570,20 @@ var workspaceProviderErrorSchema = object({
   retryable: boolean2(),
   occurred_at: string2()
 });
+var extensionWorkspaceFields = {
+  projectId: string2(),
+  isDefault: boolean2(),
+  shorthand: string2(),
+  rootPath: string2().nullable(),
+  providerId: string2(),
+  providerState: workspaceProviderStateSchema,
+  executionKind: workspaceExecutionKindSchema,
+  displayPath: string2().nullable(),
+  capabilities: workspaceCapabilitiesSchema,
+  setupError: string2().nullable(),
+  createdAt: string2(),
+  updatedAt: string2()
+};
 var workspaceAnchorSchema = extensionResourceRefSchema.extend({
   role: _enum(["primary", "context", "source", "result"]).optional()
 });
@@ -8470,7 +8599,7 @@ var workspaceSchema = object({
   provider_state: workspaceProviderStateSchema,
   execution_kind: workspaceExecutionKindSchema,
   provider_operation_id: string2().nullable(),
-  provider_operation_kind: _enum(["create", "cancel", "archive", "delete"]).nullable(),
+  provider_operation_kind: _enum(["create", "cancel", "archive", "delete"]).describe('The "archive" value is deprecated; use "delete". Historical archive operations remain readable until 0.45.').nullable(),
   provider_error_json: workspaceProviderErrorSchema.nullable(),
   provider_capabilities_json: workspaceCapabilitiesSchema,
   display_path: string2().nullable(),
@@ -8492,6 +8621,13 @@ var createWorkspaceInputSchema = object({
   anchors: array(workspaceAnchorSchema).optional(),
   shorthand_base: string2().trim().min(1).optional()
 });
+var extensionWorkspaceCreateInputSchema = object({
+  projectId: string2().min(1),
+  providerId: string2().min(1),
+  shorthandBase: string2().trim().min(1).optional(),
+  params: jsonObjectSchema.optional(),
+  anchors: array(workspaceAnchorSchema).optional()
+});
 var renameWorkspaceInputSchema = object({
   name: string2().trim().min(1, "Workspace name is required").max(120, "Workspace name must be 120 characters or less")
 });
@@ -8540,6 +8676,7 @@ var workspaceProviderDescriptorSchema = object({
   description: localizableStringSchema.optional(),
   params: extensionParamObjectSchema
 });
+var workspaceEntryMoveInputSchema = object({ destinationPath: string2().min(1) });
 
 // ../pstdio-api-contracts/src/environment.ts
 var bindEnvironmentInputSchema = environmentIdentitySchema.extend({
@@ -8681,6 +8818,21 @@ var resolveDataTableFieldKind = (values, column = {}) => {
   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/event-reference.ts
+var resolveEventReferenceId = (ref, ownerExtensionId) => {
+  if (typeof ref === "string")
+    return ref;
+  const extensionId = ref.extensionId ?? ownerExtensionId;
+  if (!extensionId || extensionId === "pstdio")
+    return ref.id;
+  const lifecycle = /^(command\.(?:requested|started|completed|rejected|failed):)(.+)$/.exec(ref.id);
+  if (lifecycle)
+    return `${lifecycle[1]}${extensionId}.command.${lifecycle[2]}`;
+  const artifact = /^artifact\.changed:(.+)$/.exec(ref.id);
+  if (artifact)
+    return `artifact.changed:${extensionId}.artifact.${artifact[1]}`;
+  return `${extensionId}.event.${ref.id}`;
+};
 // ../pstdio-api-contracts/src/extension-kernel/refs.ts
 var createCommandRef = (input) => ({ ...input, kind: "command" });
 var commandRef = Object.assign(createCommandRef, {
@@ -8707,7 +8859,7 @@ var projectSlots = {
   sidenav: defineSlot("project.sidenav", { kind: "panel" }),
   headerPrimary: resourceMenuSlotRef(workbenchResourceKinds.project, "headerPrimary"),
   headerOverflow: resourceMenuSlotRef(workbenchResourceKinds.project, "headerOverflow"),
-  settingsPanels: defineSlot("project.settingsPanels", { kind: "settings" })
+  settingsPanels: defineSlot("project.settings", { kind: "settings" })
 };
 var sessionSlots = {
   headerPrimary: resourceMenuSlotRef(workbenchResourceKinds.session, "headerPrimary"),
@@ -8740,7 +8892,6 @@ var workspaceEvents = {
   created: hostEventRef("workspace.created"),
   provision: hostEventRef("workspace.provision"),
   ready: hostEventRef("workspace.ready"),
-  archived: hostEventRef("workspace.archived"),
   deleted: hostEventRef("workspace.deleted")
 };
 var worktreeEvents = {
@@ -8846,6 +8997,254 @@ var packageAsset = (path, baseUrl) => ({
   path,
   baseUrl
 });
+// ../pstdio-api-contracts/src/extension-kernel/page-resource-codec.ts
+var fromUri = (uri) => {
+  try {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "pstdio:" || parsed.hostname !== "extension-resource")
+      return;
+    const [type, id, ...rest] = parsed.pathname.slice(1).split("/");
+    if (!type || !id || rest.length > 0)
+      return;
+    const extensionId = parsed.searchParams.get("extensionId");
+    const projectId = parsed.searchParams.get("projectId");
+    return {
+      type: decodeURIComponent(type),
+      id: decodeURIComponent(id),
+      ...extensionId ? { extensionId } : {},
+      ...projectId ? { projectId } : {}
+    };
+  } catch {
+    return;
+  }
+};
+var defaultPageResourceCodec = {
+  normalize: (resource) => ({ ...resource }),
+  toUri: (resource) => {
+    const uri = `pstdio://extension-resource/${encodeURIComponent(resource.type)}/${encodeURIComponent(resource.id)}`;
+    const query = new URLSearchParams;
+    if (resource.extensionId)
+      query.set("extensionId", resource.extensionId);
+    if (resource.projectId)
+      query.set("projectId", resource.projectId);
+    return query.size ? `${uri}?${query}` : uri;
+  },
+  fromUri
+};
+// ../pstdio-api-contracts/src/extension-kernel/page-url.ts
+var hostExtensionId = "pstdio";
+var pageRefKey = (ref) => `${ref.extensionId ?? ""}:page:${ref.id}`;
+var pageForRef = (pages, ref) => pages.find((page) => pageRefKey(page.ref) === pageRefKey(ref));
+var encodePath = (path) => path.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+var routePath = (projectId, page) => {
+  const project = `/projects/${encodeURIComponent(projectId)}`;
+  const path = encodePath(page.path);
+  if (page.ref.extensionId === hostExtensionId)
+    return path ? `${project}/${path}` : project;
+  if (!page.ref.extensionId)
+    throw new Error(`Page "${page.id}" has no extension id`);
+  return `${project}/extensions/${encodeURIComponent(page.ref.extensionId)}/${path}`;
+};
+var normalizedSection = (value) => {
+  if (!value || typeof value !== "object" || !Array.isArray(value.anchors))
+    return;
+  const anchors = value.anchors;
+  if (anchors.some((anchor) => !anchor || typeof anchor !== "object" || typeof anchor.id !== "string" || typeof anchor.heading !== "string" || anchor.occurrence !== undefined && (!Number.isInteger(anchor.occurrence) || Number(anchor.occurrence) < 0))) {
+    return;
+  }
+  return {
+    anchors: anchors.map((anchor) => {
+      const value = anchor;
+      return {
+        id: value.id,
+        heading: value.heading,
+        ...value.occurrence !== undefined ? { occurrence: value.occurrence } : {}
+      };
+    })
+  };
+};
+var serializeSection = (section) => {
+  const normalized = normalizedSection(section);
+  if (!normalized)
+    throw new Error("Page location has an invalid section");
+  return JSON.stringify(normalized);
+};
+var parseSection = (value) => {
+  try {
+    return normalizedSection(JSON.parse(value));
+  } catch {
+    return;
+  }
+};
+var serializeWorkbenchPageUrl = (input) => {
+  const page = pageForRef(input.pages, input.location.page);
+  if (!page)
+    throw new Error(`Unknown page ref: ${pageRefKey(input.location.page)}`);
+  const query = new URLSearchParams;
+  if (input.location.resource) {
+    query.set("resource", input.resources.toUri(input.resources.normalize(input.location.resource)));
+  }
+  const document = page.document && input.location.resource?.metadata?.[page.document.metadataKey];
+  if (document !== undefined) {
+    if (typeof document !== "string" || !document)
+      throw new Error("Page location has an invalid document");
+    query.set("document", document);
+  }
+  if (input.location.position) {
+    if (!page.document || typeof document !== "string" || !document || input.location.section || !isFileSourcePosition(input.location.position))
+      throw new Error("Page location has an invalid source position");
+    for (const key of ["line", "column", "endLine", "endColumn"]) {
+      const value = input.location.position[key];
+      if (value !== undefined)
+        query.set(key, String(value));
+    }
+  }
+  if (input.location.section)
+    query.set("section", serializeSection(input.location.section));
+  const params = normalizePageParams(page.params, input.location.params);
+  for (const [name, value] of pageParamsQuery(page.params, params))
+    query.append(name, value);
+  const encoded = query.toString();
+  const path = routePath(input.projectId, page);
+  return encoded ? `${path}?${encoded}` : path;
+};
+var decodedSegments = (pathname) => {
+  try {
+    return pathname.split("/").filter(Boolean).map((segment) => decodeURIComponent(segment));
+  } catch {
+    return;
+  }
+};
+var isWorkbenchProjectUrl = (urlValue, projectId) => {
+  try {
+    const url = new URL(urlValue, "http://workbench.local");
+    const segments = decodedSegments(url.pathname);
+    return Boolean(segments && segments[0] === "projects" && segments[1] === projectId);
+  } catch {
+    return false;
+  }
+};
+var pageForRoute = (pages, extensionId, path) => pages.find((page) => page.ref.extensionId === extensionId && page.path === path);
+var parseResource = (uri, resources) => {
+  try {
+    const resource = resources.fromUri(uri);
+    return resource ? resources.normalize(resource) : undefined;
+  } catch {
+    return;
+  }
+};
+var parseSourcePosition = (url, page, document, section) => {
+  const coordinates = Object.fromEntries(["line", "column", "endLine", "endColumn"].filter((key) => url.searchParams.has(key)).map((key) => {
+    const raw = url.searchParams.get(key);
+    return [key, /^[1-9]\d*$/.test(raw) ? Number(raw) : NaN];
+  }));
+  let position;
+  if (Object.keys(coordinates).length) {
+    if (!page.document || document === null || section || !isFileSourcePosition(coordinates))
+      return false;
+    position = coordinates;
+  }
+  return position;
+};
+var pageForUrl = (url, projectId, pages) => {
+  const segments = decodedSegments(url.pathname);
+  if (!segments || segments[0] !== "projects" || segments[1] !== projectId)
+    return;
+  const route = segments.slice(2);
+  const extensionRoute = route[0] === "extensions";
+  const extensionId = extensionRoute ? route[1] : hostExtensionId;
+  const path = (extensionRoute ? route.slice(2) : route).join("/");
+  if (!extensionId || extensionRoute && !path)
+    return;
+  const page = pageForRoute(pages, extensionId, path);
+  return page;
+};
+var parseWorkbenchPageUrl = (input) => {
+  let url;
+  try {
+    url = new URL(input.url, "http://workbench.local");
+  } catch {
+    return;
+  }
+  const page = pageForUrl(url, input.projectId, input.pages);
+  if (!page)
+    return;
+  for (const key of ["resource", "document", "section", "line", "column", "endLine", "endColumn"]) {
+    if (url.searchParams.getAll(key).length > 1)
+      return;
+  }
+  const resourceValue = url.searchParams.get("resource");
+  let resource = resourceValue ? parseResource(resourceValue, input.resources) : undefined;
+  if (resourceValue !== null && !resource)
+    return;
+  const document = url.searchParams.get("document");
+  if (document !== null) {
+    if (!document || !page.document || !resource)
+      return;
+    resource = { ...resource, metadata: { [page.document.metadataKey]: document } };
+  }
+  const sectionValue = url.searchParams.get("section");
+  const section = sectionValue ? parseSection(sectionValue) : undefined;
+  if (sectionValue !== null && !section)
+    return;
+  const position = parseSourcePosition(url, page, document, section);
+  if (position === false)
+    return;
+  const params = parsePageParams(page.params, url.searchParams);
+  return {
+    pageId: page.id,
+    ...params ? { params } : {},
+    ...resource ? { resource } : {},
+    ...section ? { section } : {},
+    ...position ? { position } : {}
+  };
+};
+var serializePageUrl = (input) => serializeWorkbenchPageUrl({
+  projectId: input.projectId,
+  location: { page: input.page.ref, resource: input.resource, position: input.position, params: input.params },
+  pages: [input.page],
+  resources: defaultPageResourceCodec
+});
+var parsePageUrl = (input) => {
+  if (!input.url.startsWith("/") || input.url.startsWith("//"))
+    return;
+  return parseWorkbenchPageUrl({ ...input, resources: defaultPageResourceCodec });
+};
+// ../pstdio-api-contracts/src/extension-kernel/serialize-error.ts
+var serializeCommandError = (error) => {
+  const ancestors = [];
+  const shape = (value) => ({
+    ...value,
+    name: value.name,
+    message: value.message,
+    ...value.stack ? { stack: value.stack } : {},
+    ...value.cause !== undefined ? { cause: value.cause } : {}
+  });
+  const shapes = new WeakMap;
+  const errorShape = (value) => {
+    const existing = shapes.get(value);
+    if (existing)
+      return existing;
+    const result = shape(value);
+    shapes.set(value, result);
+    return result;
+  };
+  const source = error instanceof Error ? errorShape(error) : { message: String(error) };
+  const result = JSON.parse(JSON.stringify(source, function(_key, value) {
+    const normalized = value instanceof Error ? errorShape(value) : value;
+    if (typeof normalized === "bigint")
+      return String(normalized);
+    if (normalized && typeof normalized === "object") {
+      while (ancestors.length && ancestors.at(-1) !== this)
+        ancestors.pop();
+      if (ancestors.includes(normalized))
+        return "[Circular]";
+      ancestors.push(normalized);
+    }
+    return normalized;
+  }));
+  return result;
+};
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
 var EXTENSION_API_VERSION = "0.2.0";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
@@ -8876,9 +9275,11 @@ var WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES = ["artifacts.read"];
 var ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES = ["host.dispatchKeyboardEvent"];
 var WEBVIEW_HOST_CAPABILITIES = [
   ...WEBVIEW_DECLARABLE_CAPABILITIES.filter((capability) => capability !== "clipboard.write"),
-  ...WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES,
-  ...ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES
+  ...WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES
 ];
+// ../pstdio-api-contracts/src/extension-kernel/webview-protocol.ts
+var EXTENSION_EVENTS_SCOPE = "extension.events";
+var artifactMountId = (mount) => typeof mount === "string" ? mount : mount.id;
 // ../pstdio-api-contracts/src/files.ts
 var fileRecordSchema = object({
   id: string2(),
@@ -9174,6 +9575,8 @@ var reconcileMessageHistory = (input, projection = {}) => {
     throw error;
   }
 };
+// ../pstdio-api-contracts/src/pagination.ts
+var pageQuerySchema = object({ cursor: string2().optional(), limit: exports_coerce.number().optional() });
 // ../pstdio-api-contracts/src/session-request-values.ts
 var harnessParamValueSchema = union([string2(), boolean2()]);
 var harnessParamsInputSchema = record(string2(), harnessParamValueSchema);
@@ -9261,6 +9664,7 @@ var resourceAnchorPageSchema = object({
   items: array(object({ source: resourceLinkRefSchema, target: resourceAnchorSchema })),
   nextCursor: string2().optional()
 });
+var resourceAnchorQueryPageSchema = resourceAnchorPageSchema.extend({ nextCursor: string2().nullable() });
 // ../pstdio-api-contracts/src/session-attachment-types.ts
 var sessionAttachmentMimeTypesByExtension = {
   c: "text/plain",
@@ -9418,6 +9822,42 @@ var sessionUsageSchema = object({
   cache_read_tokens: number2(),
   cache_write_tokens: number2()
 });
+var sessionExitSchema = object({
+  cause: _enum([
+    "completed",
+    "user_stop",
+    "request_aborted",
+    "worker_lost",
+    "host_shutdown",
+    "timeout",
+    "failed",
+    "unknown"
+  ]),
+  startedAt: string2().nullable(),
+  endedAt: string2()
+});
+var extensionSessionSchema = object({
+  id: string2(),
+  title: string2(),
+  status: sessionStatusSchema,
+  archived: boolean2(),
+  agent: string2().nullable(),
+  cwd: string2().nullable(),
+  lastSelectedModel: string2().nullable(),
+  workspaceId: string2().nullable(),
+  originalSessionId: string2().nullable(),
+  createdAt: string2(),
+  updatedAt: string2(),
+  lastRequestStarted: string2().nullable(),
+  lastRequestEnded: string2().nullable(),
+  lastExit: sessionExitSchema.nullable().optional(),
+  usage: object({
+    inputTokens: number2(),
+    outputTokens: number2(),
+    cacheReadTokens: number2(),
+    cacheWriteTokens: number2()
+  }).nullable()
+});
 var sessionSchema = object({
   id: string2(),
   project_id: string2().nullable(),
@@ -9439,9 +9879,18 @@ var sessionSchema = object({
   created_at: string2(),
   updated_at: string2()
 });
-var createSessionResponseSchema = sessionSchema.extend({
+var sessionDetailsSchema = extensionSessionSchema.extend({
+  projectId: string2().nullable(),
+  agentSessionId: string2().nullable(),
+  sessionFileId: string2().nullable(),
+  params: harnessParamsInputSchema.nullable()
+});
+var createSessionResponseSchema = sessionSchema.extend(extensionSessionSchema.shape).extend({
   operation_result: harnessOperationResponseSchema.optional()
 });
+var sessionCreateResponseSchema = createSessionResponseSchema.extend(sessionDetailsSchema.shape).extend({
+  operationResult: harnessOperationResponseSchema.optional()
+});
 var sessionAttachmentSchema = object({
   file_id: string2(),
   name: string2(),
@@ -9513,6 +9962,37 @@ var resolveSessionIdInputSchema = object({
 var resolveSessionIdResponseSchema = object({
   session_id: string2().nullable()
 });
+var sessionCreateRequestSchema = createSessionInputSchema.omit({ project_id: true, workspace_id: true, original_session_id: true, attachments: true }).extend({
+  attachments: array(object({ fileId: string2().min(1) })).optional(),
+  projectId: string2().min(1),
+  workspaceId: string2().optional(),
+  originalSessionId: string2().optional()
+});
+var sessionAttachmentDetailsSchema = sessionAttachmentSchema.omit({ file_id: true, mime_type: true, size_bytes: true, created_at: true, updated_at: true }).extend({
+  fileId: string2(),
+  mimeType: string2().nullable(),
+  sizeBytes: number2(),
+  createdAt: string2(),
+  updatedAt: string2()
+});
+var sessionFollowUpRequestSchema = followUpInputSchema.omit({
+  question_response: true,
+  summary_from_session_id: true,
+  summary_format: true,
+  summary_role: true,
+  attachments: true
+}).extend({
+  questionResponse: questionResponseSchema.optional(),
+  summaryFromSessionId: string2().optional(),
+  summaryFormat: _enum(["brief", "detailed"]).optional(),
+  summaryRole: _enum(["assistant", "all"]).optional(),
+  attachments: array(object({ fileId: string2().min(1) })).optional()
+});
+var sessionFollowUpDecisionSchema = union([
+  object({ status: literal("dispatched") }),
+  object({ status: literal("queued"), queuePosition: number2().int() })
+]);
+var sessionFollowUpResponseSchema = followUpResponseSchema.extend(sessionDetailsSchema.shape).extend({ followUp: sessionFollowUpDecisionSchema });
 // ../pstdio-api-contracts/src/settings.ts
 var settingsSchema = object({
   notifications_enabled: boolean2(),
@@ -9565,6 +10045,68 @@ var updateSkillInputSchema = object({
   title: string2().min(1).optional(),
   description: string2().optional()
 });
+var skillDetailsSchema = skillSchema.omit({
+  project_id: true,
+  source_kind: true,
+  extension_instance_id: true,
+  extension_id: true,
+  installed_extension_id: true,
+  install_name: true,
+  created_at: true,
+  updated_at: true,
+  deleted_at: true
+}).extend({
+  projectId: string2(),
+  sourceKind: skillSourceKindSchema,
+  extensionInstanceId: string2().optional(),
+  extensionId: string2().optional(),
+  installedExtensionId: string2().optional(),
+  installName: string2().optional(),
+  createdAt: string2(),
+  updatedAt: string2(),
+  deletedAt: string2().nullable()
+});
+var skillAgentInstallationDetailsSchema = object({
+  agentId: string2(),
+  agentName: string2(),
+  installedVersion: string2().nullable()
+});
+var skillWithContentDetailsSchema = skillDetailsSchema.extend({
+  installedAgents: array(string2()),
+  agentInstallations: array(skillAgentInstallationDetailsSchema)
+});
+// ../pstdio-api-contracts/src/workspace-diffs.ts
+var fileDiffSchema = object({
+  filePath: string2(),
+  change: _enum(["added", "deleted", "modified", "renamed", "copied", "permissionChange"]),
+  additions: number2(),
+  deletions: number2(),
+  oldContent: string2(),
+  newContent: string2(),
+  oldPath: string2().optional(),
+  newPath: string2().optional()
+});
+var fileDiffSummarySchema = fileDiffSchema.omit({ oldContent: true, newContent: true });
+var workspaceDiffResponseSchema = object({
+  workspace_id: string2(),
+  base_ref: string2(),
+  head_ref: string2(),
+  files: array(fileDiffSchema),
+  totals: object({
+    additions: number2(),
+    deletions: number2(),
+    file_count: number2()
+  })
+});
+var workspaceDiffFilesResponseSchema = workspaceDiffResponseSchema.extend({
+  files: array(fileDiffSummarySchema)
+});
+var workspaceDiffSummarySchema = object({
+  workspace_id: string2(),
+  additions: number2(),
+  deletions: number2(),
+  file_count: number2()
+});
 export {
   findViewFilterProblem,
   sessionAttachmentMimeTypesByExtension,