@pstdio/sdk 0.44.0-nightly.20261017030225 → 0.44.0

package/dist/api/index.js

@@ -4013,6 +4013,17 @@ function _array(Class, element, params) {
     ...normalizeParams(params)
   });
 }
+function _custom(Class, fn, _params) {
+  const norm = normalizeParams(_params);
+  norm.abort ?? (norm.abort = true);
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...norm
+  });
+  return schema;
+}
 function _refine(Class, fn, _params) {
   const schema = new Class({
     type: "custom",
@@ -6158,6 +6169,9 @@ var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
 });
+function custom(fn, _params) {
+  return _custom(ZodCustom, fn ?? (() => true), _params);
+}
 function refine(fn, _params = {}) {
   return _refine(ZodCustom, fn, _params);
 }
@@ -6242,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(),
@@ -6255,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",
@@ -6310,6 +6340,313 @@ 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),
+  protocolVersions: array(number2().int().positive()).min(1),
+  supportedFeatures: array(string2().min(1)),
+  requiredFeatures: array(string2().min(1))
+});
+var protocolPeer = {
+  release: "contracts-v1",
+  protocolVersions: [1],
+  supportedFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"],
+  requiredFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"]
+};
+function negotiate(client, relay) {
+  const common = client.protocolVersions.includes(1) && relay.protocolVersions.includes(1);
+  const features = client.requiredFeatures.every((feature) => relay.supportedFeatures.includes(feature)) && relay.requiredFeatures.every((feature) => client.supportedFeatures.includes(feature));
+  if (common && features)
+    return { status: "compatible", protocolVersion: 1 };
+  return {
+    status: "unsupported-protocol",
+    recoverable: true,
+    action: "Update the local runtime or relay to a common protocol and required feature set. Local work remains saved; retry after updating."
+  };
+}
+// ../pstdio-sync-contracts/src/json.ts
+function isJson(value) {
+  try {
+    JSON.stringify(value);
+  } catch {
+    return false;
+  }
+  const queue = [value];
+  const visited = new Set;
+  while (queue.length) {
+    const item = queue.pop();
+    if (item === null || typeof item === "string" || typeof item === "boolean")
+      continue;
+    if (typeof item === "number" && Number.isFinite(item))
+      continue;
+    if (typeof item !== "object" || item === null)
+      return false;
+    if (visited.has(item))
+      continue;
+    visited.add(item);
+    if (Array.isArray(item))
+      queue.push(...item);
+    else {
+      const prototype = Object.getPrototypeOf(item);
+      if (prototype !== Object.prototype && prototype !== null)
+        return false;
+      queue.push(...Object.values(item));
+    }
+  }
+  return true;
+}
+var jsonSchema = custom(isJson, "Expected a JSON value without loss of object keys");
+function dictionarySchema(valueSchema) {
+  return custom((value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => valueSchema.safeParse(entry).success), "Invalid dictionary");
+}
+
+// ../pstdio-sync-contracts/src/wire.ts
+var identitySchema = string2().min(1);
+var revisionSchema = number2().int().nonnegative();
+var fingerprintSchema = string2().regex(/^[a-f0-9]{64}$/);
+var scopeSchema = strictObject({
+  accountId: identitySchema,
+  workbenchId: identitySchema,
+  extensionId: identitySchema
+});
+var assetSchema = strictObject({
+  sha256: fingerprintSchema,
+  byteLength: revisionSchema,
+  mediaType: identitySchema
+});
+var sharedSchema = discriminatedUnion("kind", [
+  strictObject({ kind: literal("text"), update: string2().min(1) }),
+  strictObject({ kind: literal("list"), update: string2().min(1) }),
+  strictObject({
+    kind: literal("map"),
+    entries: array(strictObject({
+      key: string2(),
+      expected: fingerprintSchema,
+      next: discriminatedUnion("kind", [
+        strictObject({ kind: literal("set"), value: jsonSchema }),
+        strictObject({ kind: literal("delete") })
+      ])
+    })).min(1)
+  })
+]);
+var changeSchema = strictObject({
+  recordId: identitySchema,
+  expectedRevision: revisionSchema,
+  baseDeleted: boolean2(),
+  shared: sharedSchema.optional(),
+  value: strictObject({ expected: fingerprintSchema, next: jsonSchema }).optional(),
+  asset: strictObject({ base: assetSchema.nullable(), next: assetSchema.nullable() }).optional(),
+  deleted: boolean2().optional()
+});
+var resolutionSchema = strictObject({
+  conflictId: identitySchema,
+  expectedConflicts: array(strictObject({ conflictId: identitySchema, revision: revisionSchema })).min(1),
+  capturedOperationIds: array(identitySchema).min(1),
+  expectedInputs: array(strictObject({ recordId: identitySchema, revision: revisionSchema })).min(1),
+  handler: strictObject({ publishedRevision: identitySchema, handlerId: identitySchema }).optional()
+});
+var mutationBodySchema = strictObject({
+  protocolVersion: literal(1),
+  scope: scopeSchema,
+  environmentId: identitySchema,
+  operationId: identitySchema,
+  parents: array(identitySchema),
+  changes: array(changeSchema).min(1),
+  resolution: resolutionSchema.optional()
+});
+var localOperationSchema = mutationBodySchema.omit({ protocolVersion: true, scope: true }).superRefine(checkGroup);
+var mutationSchema = mutationBodySchema.extend({ fingerprint: fingerprintSchema }).superRefine(checkGroup);
+function checkGroup(value, ctx) {
+  const unique = (values) => new Set(values).size === values.length;
+  const records = value.changes.map((change) => change.recordId);
+  if (!unique(records) || !unique(value.parents) || value.parents.includes(value.operationId)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Records and parents must be unique; operations cannot depend on themselves"
+    });
+  }
+  for (const change of value.changes) {
+    if (!change.shared && !change.value && !change.asset && change.deleted === undefined) {
+      ctx.addIssue({ code: "custom", message: "A record change must contain an edit" });
+    }
+    if (change.shared?.kind === "map" && !unique(change.shared.entries.map((entry) => entry.key))) {
+      ctx.addIssue({ code: "custom", message: "Map keys must be unique within a change" });
+    }
+  }
+  const resolution = value.resolution;
+  if (!resolution)
+    return;
+  const inputs = resolution.expectedInputs.map((input) => input.recordId);
+  if (!unique(resolution.expectedConflicts.map((input) => input.conflictId)) || !resolution.expectedConflicts.some((input) => input.conflictId === resolution.conflictId) || !unique(inputs) || inputs.length !== records.length || records.some((id) => !inputs.includes(id)) || !unique(resolution.capturedOperationIds) || resolution.capturedOperationIds.some((id) => !value.parents.includes(id))) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Resolution inputs must cover the whole group and captured operations must be parents"
+    });
+  }
+}
+
+// ../pstdio-sync-contracts/src/fingerprint.ts
+function canonicalJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    return `{${Object.keys(value).filter((key) => value[key] !== undefined).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+async function fingerprint(value) {
+  const bytes = new TextEncoder().encode(canonicalJson(value));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sealMutation(body) {
+  const parsed = mutationSchema.parse({ ...body, fingerprint: "0".repeat(64) });
+  const { fingerprint: _ignored, ...normalized } = parsed;
+  return { ...normalized, fingerprint: await fingerprint(normalized) };
+}
+async function validateMutation(input) {
+  const mutation = mutationSchema.parse(input);
+  const { fingerprint: supplied, ...body } = mutation;
+  if (await fingerprint(body) !== supplied)
+    throw new Error("Payload fingerprint does not match");
+  return mutation;
+}
+// ../pstdio-sync-contracts/src/identity.ts
+var environmentIdentitySchema = strictObject({ environmentId: identitySchema });
+var environmentTargetSchema = environmentIdentitySchema.extend({
+  workbenchId: identitySchema,
+  workspaceId: identitySchema
+});
+// ../pstdio-sync-contracts/src/state.ts
+var checkpointSchema = strictObject({ epoch: identitySchema, sequence: revisionSchema });
+var recordSchema = strictObject({
+  recordId: identitySchema,
+  revision: revisionSchema,
+  deleted: boolean2(),
+  primitive: _enum(["text", "list", "map"]).nullable(),
+  shared: strictObject({ kind: _enum(["text", "list"]), update: string2() }).optional(),
+  map: dictionarySchema(jsonSchema),
+  value: jsonSchema,
+  asset: assetSchema.nullable()
+});
+var conflictSchema = strictObject({
+  conflictId: identitySchema,
+  revision: revisionSchema,
+  recordIds: array(identitySchema).min(1),
+  alternativeOperationIds: array(identitySchema).min(1),
+  resolvedBy: identitySchema.optional()
+});
+var receiptSchema = strictObject({
+  order: revisionSchema,
+  operationId: identitySchema,
+  fingerprint: fingerprintSchema,
+  mutation: mutationSchema,
+  status: _enum(["accepted", "conflict", "pending"]),
+  reason: string2().optional(),
+  checkpoint: checkpointSchema.nullable(),
+  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";
+  if (!identityMatches || accepted !== (receipt.checkpoint !== null) || receipt.status === "conflict" && !receipt.conflictId) {
+    ctx.addIssue({ code: "custom", message: "Receipt identity, fingerprint, outcome and checkpoint must agree" });
+  }
+});
+var snapshotSchema = strictObject({
+  protocolVersion: literal(1),
+  scope: scopeSchema,
+  journalSequence: revisionSchema,
+  checkpoint: checkpointSchema,
+  records: dictionarySchema(recordSchema),
+  receipts: dictionarySchema(receiptSchema),
+  conflicts: dictionarySchema(conflictSchema),
+  publishedRevision: identitySchema
+});
+var syncOutcomeSchema = discriminatedUnion("status", [
+  strictObject({ status: literal("saved-locally"), operationId: identitySchema }),
+  strictObject({ status: literal("pending"), operationId: identitySchema, reason: string2() }),
+  strictObject({ status: literal("synchronized"), operationId: identitySchema, checkpoint: checkpointSchema }),
+  strictObject({
+    status: literal("conflict"),
+    operationId: identitySchema,
+    conflictId: identitySchema,
+    conflictRevision: revisionSchema
+  })
+]);
+
+// ../pstdio-sync-contracts/src/replay.ts
+var replaySchema = strictObject({
+  protocolVersion: literal(1),
+  scope: scopeSchema,
+  after: checkpointSchema,
+  through: checkpointSchema,
+  groups: array(receiptSchema)
+}).superRefine((batch, ctx) => {
+  const sameEpoch = batch.after.epoch === batch.through.epoch;
+  const complete = batch.through.sequence - batch.after.sequence === batch.groups.length;
+  const validGroups = batch.groups.every((group, index) => group.status === "accepted" && group.checkpoint?.epoch === batch.through.epoch && group.checkpoint.sequence === batch.after.sequence + index + 1 && canonicalJson(group.mutation.scope) === canonicalJson(batch.scope));
+  const unique = new Set(batch.groups.map((group) => group.operationId)).size === batch.groups.length;
+  if (!sameEpoch || !complete || !validGroups || !unique)
+    ctx.addIssue({
+      code: "custom",
+      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 });
+var assetTransferSchema = discriminatedUnion("status", [
+  strictObject({
+    status: literal("staging"),
+    operationId: identitySchema,
+    expected: assetReferenceSchema,
+    uploadedByteLength: revisionSchema
+  }),
+  strictObject({ status: literal("complete"), operationId: identitySchema, asset: assetReferenceSchema }),
+  strictObject({ status: literal("cancelled"), operationId: identitySchema, expected: assetReferenceSchema })
+]);
 // ../pstdio-api-contracts/src/extensions/common.ts
 var jsonObjectSchema = record(string2(), unknown());
 var serializableJsonObjectSchema = record(string2(), json()).meta({
@@ -6484,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(),
@@ -6498,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(),
@@ -6822,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(),
@@ -6865,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(),
@@ -6893,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() };
@@ -7308,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") }),
@@ -7348,8 +7727,7 @@ var kanbanRendererSavedViewSchema = object({
   title: localizableStringSchema,
   settings: kanbanViewSettingsSchema,
   filter: viewFilterGroupSchema,
-  sorts: viewSortsSchema,
-  isDefault: boolean2().optional()
+  sorts: viewSortsSchema
 });
 var extensionKanbanRendererCreateRowSchema = object({
   commandId: string2(),
@@ -7383,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(),
@@ -7557,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(),
@@ -7686,6 +8062,8 @@ 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(),
     placement: _enum(["header-primary", "header-overflow", "context-menu"]),
@@ -7709,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),
@@ -7733,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(),
@@ -7807,7 +8175,6 @@ var checkWorkbenchMetadataSchema = workbenchExtensionMetadataSchema.pick({
   navigationItems: true,
   navigationTrees: true,
   statusBarItems: true,
-  statuses: true,
   activityItems: true,
   settingsSections: true,
   settingsPanels: true,
@@ -7990,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({
@@ -8087,78 +8461,304 @@ var boardViewCreateSchema = boardViewUpdateSchema.extend({
   title: string2().trim().min(1),
   copyFrom: string2().optional()
 });
-// ../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/data-migration.ts
+var createDataMigrationRunner = (store) => {
+  let pending = Promise.resolve();
+  return (version, run) => {
+    const result = pending.then(async () => {
+      if (!Number.isSafeInteger(version) || version < 1)
+        throw new Error("Migration version must be a positive safe integer.");
+      const previous = await store.readVersion();
+      if (!Number.isSafeInteger(previous) || previous < 0)
+        throw new Error("Stored migration version is invalid.");
+      if (previous > version)
+        throw new Error("Stored data has a newer migration version.");
+      if (previous === version)
+        return;
+      await run(previous);
+      await store.writeVersion(version);
+    });
+    pending = result.catch(() => {});
+    return result;
   };
 };
-// ../pstdio-api-contracts/src/extension-kernel/builtin-refs.ts
-var hostRef = (kind, id) => ({ extensionId: "pstdio", kind, id });
-var workbenchModes = {
-  project: hostRef("mode", "project"),
-  sessions: hostRef("mode", "sessions"),
-  settings: hostRef("mode", "settings")
-};
-var workbenchModeDefinitions = {
-  project: { ref: workbenchModes.project, regions: dockedWorkbenchRegions },
-  sessions: { ref: workbenchModes.sessions, regions: dockedWorkbenchRegions },
-  settings: { ref: workbenchModes.settings, regions: dockedWorkbenchRegions }
-};
-var hostResourceKind = (id, label, menuSlots) => ({
-  id,
-  ref: hostRef("resource-kind", id),
-  label,
-  menuSlots
+// ../pstdio-api-contracts/src/projects.ts
+var initialWorkspaceSchema = object({
+  provider_id: string2().min(1),
+  params: serializableJsonObjectSchema.default({})
 });
-var headerMenuSlots = [
-  { id: "headerPrimary", placement: "header-primary", access: "public" },
-  { id: "headerOverflow", placement: "header-overflow", access: "public" }
-];
-var workbenchResourceKindDefinitions = {
-  project: hostResourceKind("project", "Extension", headerMenuSlots),
-  session: hostResourceKind("session", "Session", headerMenuSlots),
-  workspace: hostResourceKind("workspace", "Workspace", headerMenuSlots)
-};
-var workbenchResourceKinds = {
-  project: workbenchResourceKindDefinitions.project.ref,
-  session: workbenchResourceKindDefinitions.session.ref,
-  workspace: workbenchResourceKindDefinitions.workspace.ref
+var extensionSetupWarningSchema = object({
+  code: literal("extension_setup_failed"),
+  extension: string2(),
+  message: string2()
+});
+var projectSchema = object({
+  id: string2(),
+  name: string2(),
+  shorthand: string2(),
+  default_agent_id: string2().nullable(),
+  default_agent_model: string2().nullable(),
+  startup_script: string2().nullable(),
+  created_at: string2(),
+  updated_at: string2(),
+  deleted_at: string2().nullable(),
+  extension_warnings: array(extensionSetupWarningSchema).optional()
+});
+var createProjectInputSchema = object({
+  name: string2().trim().min(1).optional(),
+  initial_workspace: initialWorkspaceSchema,
+  agents: array(string2().min(1)).min(1).optional()
+});
+var updateProjectInputSchema = object({
+  name: string2().trim().min(1).optional(),
+  default_agent_id: string2().min(1).nullable().optional(),
+  default_agent_model: string2().min(1).nullable().optional()
+}).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 = {
+  version: number2().int().positive(),
+  data: jsonObjectSchema
 };
-var workbenchPages = {
-  start: hostRef("page", "start"),
-  sessions: hostRef("page", "sessions"),
-  session: hostRef("page", "session"),
-  workspaces: hostRef("page", "workspaces"),
-  workspace: hostRef("page", "workspace")
+var workspaceProviderRefSchema = object(workspaceProviderRefShape);
+var workspaceProviderStates = [
+  "provisioning",
+  "ready",
+  "failed",
+  "cancelled",
+  "archiving",
+  "archived",
+  "deleting",
+  "provider_missing"
+];
+var workspaceProviderStateSchema = _enum(workspaceProviderStates);
+var workspaceExecutionKindSchema = _enum(["local", "remote"]);
+var workspaceCapabilitiesSchema = object({
+  files: _enum(["none", "read", "write"]),
+  diff: boolean2(),
+  merge: boolean2(),
+  rebase: boolean2(),
+  delete: boolean2()
+});
+var workspaceProviderErrorSchema = object({
+  code: string2(),
+  message: string2(),
+  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 workbenchPageDefinitions = {
-  start: {
-    ref: workbenchPages.start,
-    mode: workbenchModes.project,
-    path: "",
-    primary: { cardinality: "one", resourceKinds: [] }
-  },
-  sessions: {
-    ref: workbenchPages.sessions,
-    mode: workbenchModes.sessions,
-    path: "sessions",
-    primary: { cardinality: "one", resourceKinds: [] }
+var workspaceAnchorSchema = extensionResourceRefSchema.extend({
+  role: _enum(["primary", "context", "source", "result"]).optional()
+});
+var workspaceSchema = object({
+  id: string2(),
+  project_id: string2(),
+  name: string2(),
+  branch: string2().nullable(),
+  root_path: string2().nullable(),
+  provider_id: string2(),
+  provider_params_json: jsonObjectSchema,
+  provider_ref_json: workspaceProviderRefSchema.nullable(),
+  provider_state: workspaceProviderStateSchema,
+  execution_kind: workspaceExecutionKindSchema,
+  provider_operation_id: string2().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(),
+  is_default: boolean2(),
+  archived: boolean2(),
+  initializing: boolean2(),
+  setup_error: string2().nullable(),
+  workspace_shorthand: string2(),
+  startup_log_file_id: string2().nullable(),
+  anchors_json: array(workspaceAnchorSchema),
+  created_at: string2(),
+  updated_at: string2(),
+  deleted_at: string2().nullable()
+});
+var createWorkspaceInputSchema = object({
+  project_id: string2().min(1),
+  provider_id: string2().min(1),
+  params: jsonObjectSchema.optional(),
+  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")
+});
+var removeWorktreeResponseSchema = object({
+  removed: boolean2()
+});
+var workspaceFileEntrySchema = object({
+  path: string2(),
+  name: string2(),
+  type: _enum(["file", "directory"]),
+  size: number2().int().nonnegative().optional(),
+  modified_at: string2().optional()
+});
+var workspaceFilesResponseSchema = object({
+  workspace_id: string2(),
+  path: string2(),
+  entries: array(workspaceFileEntrySchema),
+  truncated: boolean2()
+});
+var workspaceFileContentSchema = object({
+  workspace_id: string2(),
+  path: string2(),
+  file_name: string2(),
+  mime_type: string2().optional(),
+  size: number2().int().nonnegative(),
+  encoding: _enum(["utf8", "base64"]),
+  content: string2().optional(),
+  data_url: string2().optional(),
+  editable: boolean2()
+});
+var writeWorkspaceFileInputSchema = object({
+  content: string2()
+});
+var moveWorkspaceEntryInputSchema = object({
+  destination_path: string2().min(1)
+});
+var listWorkspaceFilesInputSchema = object({
+  path: string2().optional(),
+  query: string2().optional(),
+  limit: number2().int().positive().max(500).optional()
+});
+var workspaceProviderDescriptorSchema = object({
+  id: string2(),
+  label: localizableStringSchema,
+  icon: string2().optional(),
+  description: localizableStringSchema.optional(),
+  params: extensionParamObjectSchema
+});
+var workspaceEntryMoveInputSchema = object({ destinationPath: string2().min(1) });
+
+// ../pstdio-api-contracts/src/environment.ts
+var bindEnvironmentInputSchema = environmentIdentitySchema.extend({
+  name: string2().trim().min(1),
+  initial_workspace: initialWorkspaceSchema
+});
+var environmentBindingSchema = environmentIdentitySchema.extend({
+  workbenchId: string2().min(1),
+  workspace: workspaceSchema
+});
+// ../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 = {
+  project: hostRef("mode", "project"),
+  sessions: hostRef("mode", "sessions"),
+  settings: hostRef("mode", "settings")
+};
+var workbenchModeDefinitions = {
+  project: { ref: workbenchModes.project, regions: dockedWorkbenchRegions },
+  sessions: { ref: workbenchModes.sessions, regions: dockedWorkbenchRegions },
+  settings: { ref: workbenchModes.settings, regions: dockedWorkbenchRegions }
+};
+var hostResourceKind = (id, label, menuSlots) => ({
+  id,
+  ref: hostRef("resource-kind", id),
+  label,
+  menuSlots
+});
+var headerMenuSlots = [
+  { id: "headerPrimary", placement: "header-primary", access: "public" },
+  { id: "headerOverflow", placement: "header-overflow", access: "public" }
+];
+var workbenchResourceKindDefinitions = {
+  project: hostResourceKind("project", "Extension", headerMenuSlots),
+  session: hostResourceKind("session", "Session", headerMenuSlots),
+  workspace: hostResourceKind("workspace", "Workspace", headerMenuSlots)
+};
+var workbenchResourceKinds = {
+  project: workbenchResourceKindDefinitions.project.ref,
+  session: workbenchResourceKindDefinitions.session.ref,
+  workspace: workbenchResourceKindDefinitions.workspace.ref
+};
+var workbenchPages = {
+  start: hostRef("page", "start"),
+  sessions: hostRef("page", "sessions"),
+  session: hostRef("page", "session"),
+  workspaces: hostRef("page", "workspaces"),
+  workspace: hostRef("page", "workspace")
+};
+var workbenchPageDefinitions = {
+  start: {
+    ref: workbenchPages.start,
+    mode: workbenchModes.project,
+    path: "",
+    primary: { cardinality: "one", resourceKinds: [] }
+  },
+  sessions: {
+    ref: workbenchPages.sessions,
+    mode: workbenchModes.sessions,
+    path: "sessions",
+    primary: { cardinality: "one", resourceKinds: [] }
   },
   session: {
     ref: workbenchPages.session,
@@ -8218,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, {
@@ -8244,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"),
@@ -8277,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 = {
@@ -8383,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
@@ -8413,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(),
@@ -8711,40 +9575,8 @@ var reconcileMessageHistory = (input, projection = {}) => {
     throw error;
   }
 };
-// ../pstdio-api-contracts/src/projects.ts
-var initialWorkspaceSchema = object({
-  provider_id: string2().min(1),
-  params: serializableJsonObjectSchema.default({})
-});
-var extensionSetupWarningSchema = object({
-  code: literal("extension_setup_failed"),
-  extension: string2(),
-  message: string2()
-});
-var projectSchema = object({
-  id: string2(),
-  name: string2(),
-  shorthand: string2(),
-  default_agent_id: string2().nullable(),
-  default_agent_model: string2().nullable(),
-  startup_script: string2().nullable(),
-  created_at: string2(),
-  updated_at: string2(),
-  deleted_at: string2().nullable(),
-  extension_warnings: array(extensionSetupWarningSchema).optional()
-});
-var createProjectInputSchema = object({
-  name: string2().trim().min(1).optional(),
-  initial_workspace: initialWorkspaceSchema,
-  agents: array(string2().min(1)).min(1).optional()
-});
-var updateProjectInputSchema = object({
-  name: string2().trim().min(1).optional(),
-  default_agent_id: string2().min(1).nullable().optional(),
-  default_agent_model: string2().min(1).nullable().optional()
-}).refine((value) => Object.keys(value).length > 0, {
-  message: "At least one field must be provided"
-});
+// ../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);
@@ -8832,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",
@@ -8989,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(),
@@ -9010,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(),
@@ -9084,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(),
@@ -9136,122 +10045,67 @@ var updateSkillInputSchema = object({
   title: string2().min(1).optional(),
   description: string2().optional()
 });
-// ../pstdio-api-contracts/src/workspaces.ts
-var workspaceProviderRefShape = {
-  version: number2().int().positive(),
-  data: jsonObjectSchema
-};
-var workspaceProviderRefSchema = object(workspaceProviderRefShape);
-var workspaceProviderStates = [
-  "provisioning",
-  "ready",
-  "failed",
-  "cancelled",
-  "archiving",
-  "archived",
-  "deleting",
-  "provider_missing"
-];
-var workspaceProviderStateSchema = _enum(workspaceProviderStates);
-var workspaceExecutionKindSchema = _enum(["local", "remote"]);
-var workspaceCapabilitiesSchema = object({
-  files: _enum(["none", "read", "write"]),
-  diff: boolean2(),
-  merge: boolean2(),
-  rebase: boolean2(),
-  archive: boolean2(),
-  delete: boolean2()
-});
-var workspaceProviderErrorSchema = object({
-  code: string2(),
-  message: string2(),
-  retryable: boolean2(),
-  occurred_at: string2()
-});
-var workspaceAnchorSchema = extensionResourceRefSchema.extend({
-  role: _enum(["primary", "context", "source", "result"]).optional()
-});
-var workspaceSchema = object({
-  id: string2(),
-  project_id: string2(),
-  name: string2(),
-  branch: string2().nullable(),
-  root_path: string2().nullable(),
-  provider_id: string2(),
-  provider_params_json: jsonObjectSchema,
-  provider_ref_json: workspaceProviderRefSchema.nullable(),
-  provider_state: workspaceProviderStateSchema,
-  execution_kind: workspaceExecutionKindSchema,
-  provider_operation_id: string2().nullable(),
-  provider_operation_kind: _enum(["create", "cancel", "archive", "delete"]).nullable(),
-  provider_error_json: workspaceProviderErrorSchema.nullable(),
-  provider_capabilities_json: workspaceCapabilitiesSchema,
-  display_path: string2().nullable(),
-  is_default: boolean2(),
-  archived: boolean2(),
-  initializing: boolean2(),
-  setup_error: string2().nullable(),
-  workspace_shorthand: string2(),
-  startup_log_file_id: string2().nullable(),
-  anchors_json: array(workspaceAnchorSchema),
-  created_at: string2(),
-  updated_at: string2(),
-  deleted_at: string2().nullable()
-});
-var createWorkspaceInputSchema = object({
-  project_id: string2().min(1),
-  provider_id: string2().min(1),
-  params: jsonObjectSchema.optional(),
-  anchors: array(workspaceAnchorSchema).optional(),
-  shorthand_base: string2().trim().min(1).optional()
-});
-var renameWorkspaceInputSchema = object({
-  name: string2().trim().min(1, "Workspace name is required").max(120, "Workspace name must be 120 characters or less")
-});
-var removeWorktreeResponseSchema = object({
-  removed: boolean2()
-});
-var workspaceFileEntrySchema = object({
-  path: string2(),
-  name: string2(),
-  type: _enum(["file", "directory"]),
-  size: number2().int().nonnegative().optional(),
-  modified_at: string2().optional()
-});
-var workspaceFilesResponseSchema = object({
-  workspace_id: string2(),
-  path: string2(),
-  entries: array(workspaceFileEntrySchema),
-  truncated: boolean2()
-});
-var workspaceFileContentSchema = object({
+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(),
-  path: string2(),
-  file_name: string2(),
-  mime_type: string2().optional(),
-  size: number2().int().nonnegative(),
-  encoding: _enum(["utf8", "base64"]),
-  content: string2().optional(),
-  data_url: string2().optional(),
-  editable: boolean2()
-});
-var writeWorkspaceFileInputSchema = object({
-  content: string2()
-});
-var moveWorkspaceEntryInputSchema = object({
-  destination_path: string2().min(1)
+  base_ref: string2(),
+  head_ref: string2(),
+  files: array(fileDiffSchema),
+  totals: object({
+    additions: number2(),
+    deletions: number2(),
+    file_count: number2()
+  })
 });
-var listWorkspaceFilesInputSchema = object({
-  path: string2().optional(),
-  query: string2().optional(),
-  limit: number2().int().positive().max(500).optional()
+var workspaceDiffFilesResponseSchema = workspaceDiffResponseSchema.extend({
+  files: array(fileDiffSummarySchema)
 });
-var workspaceProviderDescriptorSchema = object({
-  id: string2(),
-  label: localizableStringSchema,
-  icon: string2().optional(),
-  description: localizableStringSchema.optional(),
-  params: extensionParamObjectSchema
+var workspaceDiffSummarySchema = object({
+  workspace_id: string2(),
+  additions: number2(),
+  deletions: number2(),
+  file_count: number2()
 });
 export {
   findViewFilterProblem,