@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/content/validation/portable-content-data.js

@@ -0,0 +1,49 @@
+import { buildBuiltinModelRegistry, resolveModelDefinition } from "../../entrypoints/models/model-registry.js";
+import { normalizeRecordToCanonicalShape } from "../../entrypoints/models/sdk-fields.js";
+import { isPortableContentModel, validateContentFrontmatter } from "./content-model-schemas.js";
+const registryIndependentModels = /* @__PURE__ */ new Set([
+  "agent_test",
+  "workday",
+  "template_product",
+  "agent_context_query",
+  "agent_context_query_set",
+  "agent_instruction_template",
+  "discussion_topic",
+  "assignment_plan",
+  "assignment_status",
+  "assignment_summary",
+  "agent_evaluation"
+]);
+class PortableContentValidationError extends Error {
+  constructor(details) {
+    super(`Content failed model validation with ${details.length} field error${details.length === 1 ? "" : "s"}.`);
+    this.details = details;
+    this.name = "PortableContentValidationError";
+  }
+  details;
+  code = "content_model_invalid";
+}
+function validatePortableContentData(model, value, registry = buildBuiltinModelRegistry()) {
+  if (!isPortableContentModel(model)) return { ok: true, data: value, diagnostics: [], portable: false };
+  if (registryIndependentModels.has(model)) return { ...validateContentFrontmatter(model, value), portable: true };
+  const definition = resolveModelDefinition(model, registry);
+  const frontmatter = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const canonical = definition.name === "agent" ? frontmatter : normalizeRecordToCanonicalShape(definition, frontmatter);
+  return { ...validateContentFrontmatter(model, canonical), portable: true };
+}
+function assertPortableContentData(model, value, input = {}) {
+  const result = validatePortableContentData(model, value, input.registry);
+  if (!result.ok) throw new PortableContentValidationError(result.diagnostics.map((diagnostic) => ({
+    ...input.path ? { path: input.path } : {},
+    model,
+    field: diagnostic.field,
+    code: diagnostic.code,
+    message: diagnostic.message
+  })));
+  return result.data;
+}
+export {
+  PortableContentValidationError,
+  assertPortableContentData,
+  validatePortableContentData
+};

package/dist/entrypoints/clients/control-plane-client.d.ts

@@ -0,0 +1,112 @@
+import type { ControlPlaneOperationBinding, ControlPlaneOperationBody, ControlPlaneOperationOutput, ControlPlaneOperationPath, ControlPlaneOperationQuery, OAuthScope } from '../../operator-contracts/control-plane-operation.js';
+import type { ApiPrincipal } from '../../operator-contracts/oauth.js';
+export declare const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+export declare const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+export interface ControlPlaneServerProfile {
+    serverId: string;
+    label: string;
+    baseUrl: string;
+}
+export interface ControlPlaneServerSession {
+    serverId: string;
+    audience: string;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    principal?: ApiPrincipal | null;
+}
+export interface ControlPlaneServerRegistry {
+    version: 1;
+    activeServerId: string;
+    servers: ControlPlaneServerProfile[];
+}
+export interface OAuthDeviceAuthorizationReceipt {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    expiresIn: number;
+    interval: number;
+}
+export interface OAuthTokenReceipt {
+    tokenType: 'Bearer';
+    accessToken: string;
+    expiresIn: number;
+    refreshToken?: string;
+    scope: OAuthScope[];
+    audience: string;
+    principal?: ApiPrincipal | null;
+}
+export interface ControlPlaneClientOptions {
+    profile: ControlPlaneServerProfile;
+    accessToken?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export interface ControlPlaneResponseEnvelope<T> {
+    data: T;
+    meta?: Record<string, unknown>;
+    links?: Record<string, string>;
+}
+export interface ProblemDetails {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    code: string;
+    requestId?: string;
+    traceId?: string;
+    fields?: Record<string, string[]>;
+}
+export interface ControlPlaneCallOptions {
+    method?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+    path: `/v1/${string}` | '/openapi.json';
+    input?: unknown;
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+    ifMatch?: string;
+    authorization?: string | null;
+    signal?: AbortSignal;
+}
+export interface ControlPlaneOperationCallOptions {
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+    ifMatch?: string;
+    authorization?: string | null;
+    signal?: AbortSignal;
+}
+export interface ControlPlaneInvocation<TPath, TQuery, TBody> {
+    path: TPath;
+    query: TQuery;
+    body: TBody;
+}
+export declare class ControlPlaneClientError extends Error {
+    readonly status: number;
+    readonly problem: ProblemDetails;
+    readonly responseHeaders: Headers;
+    constructor(message: string, status: number, problem: ProblemDetails, responseHeaders: Headers);
+}
+export declare function normalizeControlPlaneBaseUrl(value: string): string;
+export declare function defaultLocalControlPlaneServer(env?: Record<string, string | undefined>): ControlPlaneServerProfile;
+export declare function normalizeControlPlaneServerRegistry(state: ControlPlaneServerRegistry): {
+    version: 1;
+    activeServerId: string;
+    servers: ControlPlaneServerProfile[];
+};
+export declare function resolveControlPlaneServer(selector: string | null | undefined, registry: ControlPlaneServerRegistry): ControlPlaneServerProfile;
+export declare class ControlPlaneClient {
+    readonly options: ControlPlaneClientOptions;
+    readonly baseUrl: string;
+    readonly accessToken: string | null;
+    readonly fetchImpl: typeof fetch;
+    readonly userAgent?: string;
+    constructor(options: ControlPlaneClientOptions);
+    invoke<TOperation extends ControlPlaneOperationBinding<any, any, any, any>>(binding: TOperation, input: ControlPlaneInvocation<ControlPlaneOperationPath<TOperation>, ControlPlaneOperationQuery<TOperation>, ControlPlaneOperationBody<TOperation>>, options?: ControlPlaneOperationCallOptions): Promise<ControlPlaneResponseEnvelope<ControlPlaneOperationOutput<TOperation>>>;
+    authorizeDevice(clientId: string, scope: OAuthScope[], signal?: AbortSignal): Promise<OAuthDeviceAuthorizationReceipt>;
+    exchangeDeviceCode(clientId: string, deviceCode: string, signal?: AbortSignal): Promise<OAuthTokenReceipt>;
+    refreshAccessToken(clientId: string, refreshToken: string, signal?: AbortSignal): Promise<OAuthTokenReceipt>;
+    revokeToken(clientId: string, token: string, signal?: AbortSignal): Promise<void>;
+    private exchangeOAuthToken;
+    private request;
+}

package/dist/entrypoints/clients/control-plane-client.js

@@ -0,0 +1,180 @@
+import { controlPlaneOperation } from "../../operator-contracts/control-plane-operations.js";
+const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+class ControlPlaneClientError extends Error {
+  constructor(message, status, problem, responseHeaders) {
+    super(message);
+    this.status = status;
+    this.problem = problem;
+    this.responseHeaders = responseHeaders;
+    this.name = "ControlPlaneClientError";
+  }
+  status;
+  problem;
+  responseHeaders;
+}
+function normalizeControlPlaneBaseUrl(value) {
+  const normalized = value.trim().replace(/\/+$/u, "");
+  if (!/^https?:\/\//u.test(normalized)) throw new Error("Control-plane server URLs must use HTTP or HTTPS.");
+  return normalized;
+}
+function defaultLocalControlPlaneServer(env = process.env) {
+  return {
+    serverId: "local",
+    label: "Local TreeSeed control plane",
+    baseUrl: normalizeControlPlaneBaseUrl(env[CONTROL_PLANE_BASE_URL_ENV] ?? DEFAULT_CONTROL_PLANE_BASE_URL)
+  };
+}
+function normalizeServer(profile) {
+  const serverId = profile.serverId.trim();
+  if (!serverId) throw new Error("Control-plane server IDs cannot be empty.");
+  return { serverId, label: profile.label.trim() || serverId, baseUrl: normalizeControlPlaneBaseUrl(profile.baseUrl) };
+}
+function normalizeControlPlaneServerRegistry(state) {
+  const servers = [...new Map(state.servers.map((entry) => {
+    const normalized = normalizeServer(entry);
+    return [normalized.serverId, normalized];
+  })).values()].sort((left, right) => left.serverId.localeCompare(right.serverId));
+  if (servers.length === 0) throw new Error("A control-plane server registry requires at least one server.");
+  const activeServerId = servers.some((entry) => entry.serverId === state.activeServerId) ? state.activeServerId : servers[0].serverId;
+  return { version: 1, activeServerId, servers };
+}
+function resolveControlPlaneServer(selector, registry) {
+  const value = selector?.trim();
+  if (value && /^https?:\/\//iu.test(value)) {
+    return normalizeServer({ serverId: value.replace(/^https?:\/\//iu, "").replace(/[^a-z0-9._-]+/giu, "-"), label: value, baseUrl: value });
+  }
+  const normalized = normalizeControlPlaneServerRegistry(registry);
+  const serverId = value || normalized.activeServerId;
+  const profile = normalized.servers.find((entry) => entry.serverId === serverId);
+  if (!profile) throw new Error(`Unknown control-plane server "${serverId}".`);
+  return profile;
+}
+async function responsePayload(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("json")) return response.json();
+  const text = await response.text();
+  return text.length > 0 ? text : null;
+}
+function problemFrom(payload, status) {
+  const source = payload && typeof payload === "object" ? payload : {};
+  return {
+    type: typeof source.type === "string" ? source.type : "about:blank",
+    title: typeof source.title === "string" ? source.title : "Control-plane request failed",
+    status,
+    detail: typeof source.detail === "string" ? source.detail : void 0,
+    instance: typeof source.instance === "string" ? source.instance : void 0,
+    code: typeof source.code === "string" ? source.code : "control_plane_request_failed",
+    requestId: typeof source.requestId === "string" ? source.requestId : void 0,
+    traceId: typeof source.traceId === "string" ? source.traceId : void 0,
+    fields: source.fields && typeof source.fields === "object" ? source.fields : void 0
+  };
+}
+class ControlPlaneClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeControlPlaneBaseUrl(options.profile.baseUrl);
+    this.accessToken = options.accessToken ?? null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  options;
+  baseUrl;
+  accessToken;
+  fetchImpl;
+  userAgent;
+  async invoke(binding, input, options = {}) {
+    if (controlPlaneOperation(binding.descriptor.operationId) !== binding) {
+      throw new Error(`Operation ${binding.descriptor.operationId} is not the authoritative catalog binding.`);
+    }
+    const rest = binding.descriptor.rest;
+    if (!rest) throw new Error(`Operation ${binding.descriptor.operationId} has no REST binding.`);
+    const pathInput = binding.schema.path.parse(input.path);
+    const queryInput = binding.schema.query.parse(input.query);
+    const bodyInput = binding.schema.body.parse(input.body);
+    let path = rest.path;
+    path = path.replace(/\{([A-Za-z][A-Za-z0-9]*)\}/gu, (_match, name) => {
+      const value = pathInput[name];
+      if (typeof value !== "string" && typeof value !== "number") throw new Error(`Operation ${binding.descriptor.operationId} requires path parameter ${name}.`);
+      return encodeURIComponent(String(value));
+    });
+    if (path.includes("{")) throw new Error(`Operation ${binding.descriptor.operationId} has unresolved path parameters.`);
+    const query = new URLSearchParams();
+    for (const [name, value] of Object.entries(queryInput)) {
+      if (value === void 0 || value === null) continue;
+      for (const item of Array.isArray(value) ? value : [value]) query.append(name, String(item));
+    }
+    const queryString = query.toString();
+    const response = await this.request({
+      method: rest.method,
+      path: `${path}${queryString ? `?${queryString}` : ""}`,
+      input: rest.method === "GET" ? void 0 : bodyInput,
+      ...options
+    });
+    return { ...response, data: binding.schema.output.parse(response.data) };
+  }
+  async authorizeDevice(clientId, scope, signal) {
+    const response = await this.fetchImpl(`${this.baseUrl}/oauth/device_authorization`, { method: "POST", headers: { accept: "application/json", "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_id: clientId, scope: scope.join(" ") }), signal });
+    const payload = await responsePayload(response);
+    if (!response.ok) throw new ControlPlaneClientError(String(payload.error_description ?? payload.error ?? "Device authorization failed."), response.status, problemFrom(payload, response.status), response.headers);
+    return { deviceCode: String(payload.device_code), userCode: String(payload.user_code), verificationUri: String(payload.verification_uri), verificationUriComplete: typeof payload.verification_uri_complete === "string" ? payload.verification_uri_complete : void 0, expiresIn: Number(payload.expires_in), interval: Number(payload.interval) };
+  }
+  async exchangeDeviceCode(clientId, deviceCode, signal) {
+    return this.exchangeOAuthToken({ client_id: clientId, grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: deviceCode }, signal);
+  }
+  async refreshAccessToken(clientId, refreshToken, signal) {
+    return this.exchangeOAuthToken({ client_id: clientId, grant_type: "refresh_token", refresh_token: refreshToken }, signal);
+  }
+  async revokeToken(clientId, token, signal) {
+    const response = await this.fetchImpl(`${this.baseUrl}/oauth/revoke`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_id: clientId, token }), signal });
+    if (!response.ok) throw new ControlPlaneClientError("Token revocation failed.", response.status, problemFrom(await responsePayload(response), response.status), response.headers);
+  }
+  async exchangeOAuthToken(values, signal) {
+    const response = await this.fetchImpl(`${this.baseUrl}/oauth/token`, { method: "POST", headers: { accept: "application/json", "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(values), signal });
+    const payload = await responsePayload(response);
+    if (!response.ok) throw new ControlPlaneClientError(String(payload.error_description ?? payload.error ?? "OAuth token exchange failed."), response.status, problemFrom(payload, response.status), response.headers);
+    return { tokenType: "Bearer", accessToken: String(payload.access_token), refreshToken: typeof payload.refresh_token === "string" ? payload.refresh_token : void 0, expiresIn: Number(payload.expires_in), scope: String(payload.scope ?? "").split(/\s+/u).filter(Boolean), audience: String(payload.audience ?? this.baseUrl), principal: payload.principal && typeof payload.principal === "object" ? payload.principal : void 0 };
+  }
+  async request(options) {
+    const headers = new Headers(options.headers);
+    headers.set("accept", "application/json, application/problem+json");
+    if (options.authorization !== null) {
+      const authorization = options.authorization ?? (this.accessToken ? `Bearer ${this.accessToken}` : null);
+      if (authorization) headers.set("authorization", authorization);
+    }
+    if (this.userAgent) headers.set("user-agent", this.userAgent);
+    if (options.idempotencyKey) headers.set("idempotency-key", options.idempotencyKey);
+    if (options.ifMatch) headers.set("if-match", options.ifMatch);
+    if (options.input !== void 0) headers.set("content-type", "application/json");
+    const response = await this.fetchImpl(`${this.baseUrl}${options.path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.input === void 0 ? void 0 : JSON.stringify(options.input),
+      signal: options.signal
+    });
+    const payload = await responsePayload(response);
+    if (!response.ok) {
+      const problem = problemFrom(payload, response.status);
+      throw new ControlPlaneClientError(problem.detail ?? problem.title, response.status, problem, response.headers);
+    }
+    if (!payload || typeof payload !== "object" || !("data" in payload)) {
+      throw new ControlPlaneClientError("The control plane returned an invalid success envelope.", 502, {
+        type: "https://treeseed.dev/problems/invalid-upstream-response",
+        title: "Invalid control-plane response",
+        status: 502,
+        code: "control_plane_response_invalid"
+      }, response.headers);
+    }
+    return payload;
+  }
+}
+export {
+  CONTROL_PLANE_BASE_URL_ENV,
+  ControlPlaneClient,
+  ControlPlaneClientError,
+  DEFAULT_CONTROL_PLANE_BASE_URL,
+  defaultLocalControlPlaneServer,
+  normalizeControlPlaneBaseUrl,
+  normalizeControlPlaneServerRegistry,
+  resolveControlPlaneServer
+};

package/dist/entrypoints/models/field-aliases.d.ts

@@ -0,0 +1,11 @@
+export interface FieldAliasBinding {
+    key: string;
+    aliases?: string[];
+    normalize?: (value: unknown) => unknown;
+}
+export type FieldAliasRegistry<TBinding extends FieldAliasBinding = FieldAliasBinding> = Record<string, TBinding>;
+export declare function resolveAliasedField<TBinding extends FieldAliasBinding>(registry: FieldAliasRegistry<TBinding>, requestedField: string): TBinding;
+export declare function normalizeAliasedRecord<TBinding extends FieldAliasBinding>(registry: FieldAliasRegistry<TBinding>, source: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function preprocessAliasedRecord<TBinding extends FieldAliasBinding>(registry: FieldAliasRegistry<TBinding>, value: unknown): unknown;

package/dist/entrypoints/models/model-registry.d.ts

@@ -0,0 +1,3 @@
+export * from '../../model-registry/build-builtin-model-registry.js';
+export * from '../../model-registry/content-root.js';
+export * from '../../model-registry/normalize-definition.js';

package/dist/entrypoints/models/model-registry.js

@@ -0,0 +1,3 @@
+export * from "../../model-registry/build-builtin-model-registry.js";
+export * from "../../model-registry/content-root.js";
+export * from "../../model-registry/normalize-definition.js";

package/dist/entrypoints/models/sdk-fields.d.ts

@@ -0,0 +1,11 @@
+import type { SdkFilterCondition, SdkModelDefinition, SdkModelFieldBinding, SdkSortSpec } from './sdk-types.js';
+export declare function validateModelFieldAliases(definition: SdkModelDefinition): void;
+export declare function resolveModelField(definition: SdkModelDefinition, requestedField: string): SdkModelFieldBinding;
+export declare function readCanonicalFieldValue(definition: SdkModelDefinition, record: Record<string, unknown>, canonicalField: string): unknown;
+export declare function normalizeRecordToCanonicalShape(definition: SdkModelDefinition, record: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeMutationData(definition: SdkModelDefinition, data: Record<string, unknown>): Record<string, unknown>;
+export declare function canonicalizeFrontmatter(definition: SdkModelDefinition, frontmatter: Record<string, unknown>, updates?: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function normalizeFilterFields(definition: SdkModelDefinition, filters?: SdkFilterCondition[]): SdkFilterCondition[];
+export declare function normalizeSortFields(definition: SdkModelDefinition, sort?: SdkSortSpec[]): SdkSortSpec[];

package/dist/entrypoints/models/sdk-types.d.ts

@@ -0,0 +1,10 @@
+export * from '../../sdk-types/configuration/sdk-dispatch-credential-source.js';
+export * from '../../sdk-types/governance/commons/commons-question-input.js';
+export * from '../../sdk-types/support/planning-policy.js';
+export * from '../../sdk-types/support/task-planning.js';
+export * from '../../sdk-types/support/platform-contracts.js';
+export * from '../../sdk-types/support/sdk-model-names.js';
+export * from '../../sdk-types/support/sdk-search-request.js';
+export * from '../../sdk-types/treedx/graph/sdk-graph-query-request.js';
+export * from '../../projects/projects-core/project-workflow.js';
+export * from '../../sdk-types/control-plane/resource-requests.js';

package/dist/entrypoints/models/sdk-types.js

@@ -0,0 +1,10 @@
+export * from "../../sdk-types/configuration/sdk-dispatch-credential-source.js";
+export * from "../../sdk-types/governance/commons/commons-question-input.js";
+export * from "../../sdk-types/support/planning-policy.js";
+export * from "../../sdk-types/support/task-planning.js";
+export * from "../../sdk-types/support/platform-contracts.js";
+export * from "../../sdk-types/support/sdk-model-names.js";
+export * from "../../sdk-types/support/sdk-search-request.js";
+export * from "../../sdk-types/treedx/graph/sdk-graph-query-request.js";
+export * from "../../projects/projects-core/project-workflow.js";
+export * from "../../sdk-types/control-plane/resource-requests.js";

package/dist/feedback/contracts.d.ts

@@ -0,0 +1,142 @@
+export declare const FEEDBACK_TYPES: readonly ["bug", "feature_suggestion", "question", "content_issue", "ux_issue"];
+export declare const FEEDBACK_STATUSES: readonly ["new", "triaged", "in_progress", "resolved"];
+export type FeedbackType = (typeof FEEDBACK_TYPES)[number];
+export type FeedbackStatus = (typeof FEEDBACK_STATUSES)[number];
+export interface FeedbackSubmissionContext {
+    canonicalPath: string;
+    routePattern?: string;
+    capabilityId?: string;
+    teamId?: string;
+    projectId?: string;
+    environment?: 'local' | 'staging' | 'production';
+    buildId?: string;
+    revision?: string;
+    source?: 'page' | 'help';
+    knowledgePageId?: string;
+}
+export interface FeedbackClientContext {
+    userAgent?: string;
+    viewport: {
+        width: number;
+        height: number;
+        devicePixelRatio: number;
+    };
+    locale?: string;
+    timeZone?: string;
+    theme?: string;
+    reducedMotion?: boolean;
+}
+export interface FeedbackScreenshotCapture {
+    dataUrl: string;
+    mimeType: 'image/png';
+    byteSize: number;
+    width: number;
+    height: number;
+    digest: string;
+    redactionVersion: string;
+    maskedRegionCount: number;
+    redacted: true;
+}
+export interface FeedbackSubmissionRequest {
+    type: FeedbackType;
+    message: string;
+    allowContact: boolean;
+    context: FeedbackSubmissionContext;
+    client: FeedbackClientContext;
+    screenshot?: FeedbackScreenshotCapture;
+}
+export interface FeedbackAttachmentMetadata {
+    id: string;
+    feedbackId: string;
+    mimeType: 'image/png' | 'application/zip';
+    byteSize: number;
+    width?: number;
+    height?: number;
+    digest: string;
+    redactionVersion?: string;
+    maskedRegionCount?: number;
+    createdAt: string;
+    expiresAt?: string;
+    expiredAt?: string;
+}
+export interface FeedbackStatusEvent {
+    id: string;
+    fromStatus?: FeedbackStatus;
+    toStatus: FeedbackStatus;
+    note?: string;
+    actorId: string;
+    actorLabel?: string;
+    createdAt: string;
+}
+export interface FeedbackSummary {
+    id: string;
+    type: FeedbackType;
+    status: FeedbackStatus;
+    message: string;
+    submitterId: string;
+    submitterLabel?: string;
+    teamId?: string;
+    teamLabel?: string;
+    projectId?: string;
+    canonicalPath: string;
+    hasScreenshot: boolean;
+    exported: boolean;
+    createdAt: string;
+    updatedAt: string;
+    resolvedAt?: string;
+    version: number;
+}
+export interface FeedbackDetail extends FeedbackSummary {
+    allowContact: boolean;
+    contactEmail?: string;
+    context: FeedbackSubmissionContext;
+    client: FeedbackClientContext;
+    attachments: FeedbackAttachmentMetadata[];
+    history: FeedbackStatusEvent[];
+}
+export interface FeedbackCollectionFilters {
+    query?: string;
+    status?: FeedbackStatus;
+    type?: FeedbackType;
+    teamId?: string;
+    hasScreenshot?: boolean;
+    exported?: boolean;
+    from?: string;
+    to?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface FeedbackCollection {
+    items: FeedbackSummary[];
+    nextCursor?: string;
+    teams?: Array<{
+        id: string;
+        slug: string;
+        label: string;
+    }>;
+    counts: Record<FeedbackStatus, number>;
+}
+export interface FeedbackPrivacyManifest {
+    schema: 'treeseed.feedback-export/v1';
+    createdAt: string;
+    sourceClosure?: string;
+    filters: FeedbackCollectionFilters;
+    count: number;
+    includeScreenshots: boolean;
+    omittedFields: string[];
+    redactionPolicy: string;
+}
+export interface FeedbackExportRecord {
+    id: string;
+    status: 'queued' | 'running' | 'ready' | 'failed' | 'expired';
+    itemCount: number;
+    includeScreenshots: boolean;
+    createdAt: string;
+    expiresAt: string;
+    completedAt?: string;
+    error?: string;
+}
+export declare const FEEDBACK_CAPTURE_VERSION = "treeseed.feedback-capture/v3";
+export declare const FEEDBACK_EXPORT_SCHEMA = "treeseed.feedback-export/v1";
+export declare function isFeedbackType(value: unknown): value is FeedbackType;
+export declare function isFeedbackStatus(value: unknown): value is FeedbackStatus;

package/dist/feedback/contracts.js

@@ -0,0 +1,18 @@
+const FEEDBACK_TYPES = ["bug", "feature_suggestion", "question", "content_issue", "ux_issue"];
+const FEEDBACK_STATUSES = ["new", "triaged", "in_progress", "resolved"];
+const FEEDBACK_CAPTURE_VERSION = "treeseed.feedback-capture/v3";
+const FEEDBACK_EXPORT_SCHEMA = "treeseed.feedback-export/v1";
+function isFeedbackType(value) {
+  return typeof value === "string" && FEEDBACK_TYPES.includes(value);
+}
+function isFeedbackStatus(value) {
+  return typeof value === "string" && FEEDBACK_STATUSES.includes(value);
+}
+export {
+  FEEDBACK_CAPTURE_VERSION,
+  FEEDBACK_EXPORT_SCHEMA,
+  FEEDBACK_STATUSES,
+  FEEDBACK_TYPES,
+  isFeedbackStatus,
+  isFeedbackType
+};

package/dist/feedback/index.d.ts

@@ -0,0 +1 @@
+export * from './contracts.js';

package/dist/feedback/index.js

@@ -0,0 +1 @@
+export * from "./contracts.js";

package/dist/governance/groups/contracts.d.ts

@@ -0,0 +1,102 @@
+export declare const GROUP_CONTRACT: "treeseed.group/v1";
+export declare const GROUP_EDGE_CONTRACT: "treeseed.group-edge/v1";
+export interface GroupRef {
+    projectId: string;
+    groupId: string;
+    immutableRef?: string;
+    digest?: string;
+}
+export type GroupMemberKind = 'agent' | 'person' | 'content';
+export interface GroupMemberRef {
+    kind: GroupMemberKind;
+    id: string;
+    projectId: string;
+    groupIds: string[];
+    roleIds?: string[];
+    immutableRef?: string;
+}
+export interface GroupCoordinationPolicy {
+    proposalTypes?: string[];
+    eligibleActivityProfiles?: string[];
+    participation?: {
+        strategy: 'all-eligible' | 'bounded';
+        minParticipants?: number;
+        maxParticipants?: number;
+    };
+    humanRoles?: string[];
+    agentRoles?: string[];
+    reviewQuorum?: number;
+    handoffGroupRefs?: GroupRef[];
+    allocationDefaults?: {
+        priority?: number;
+        budgetShare?: number;
+    };
+}
+export interface GovernanceGroup {
+    contract: typeof GROUP_CONTRACT;
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    classification: string;
+    aliases: string[];
+    status: 'active' | 'archived';
+    coordination?: GroupCoordinationPolicy;
+}
+export interface GovernanceGroupEdge {
+    contract: typeof GROUP_EDGE_CONTRACT;
+    id: string;
+    fromGroupId: string;
+    toGroupId: string;
+    predicate: string;
+    propagatesMembership: boolean;
+}
+export interface GroupMembershipProvenance {
+    groupId: string;
+    kind: 'direct' | 'inherited' | 'subject' | 'proposal-snapshot';
+    viaGroupIds: string[];
+    sourceEntityRefs: string[];
+}
+export interface EffectiveGroupMembership {
+    projectId?: string;
+    directGroupIds: string[];
+    effectiveGroupIds: string[];
+    provenance: GroupMembershipProvenance[];
+}
+export interface DecisionGroupSnapshot extends EffectiveGroupMembership {
+    proposalId: string;
+    proposalCommitSha: string;
+    capturedAt: string;
+}
+export interface GroupMembershipSnapshot extends EffectiveGroupMembership {
+    projectId: string;
+    graphRevision: string;
+    immutableRef: string;
+    digest: string;
+    capturedAt: string;
+}
+export type SignalGroupScope = {
+    mode: 'member-groups';
+} | {
+    mode: 'specific-groups';
+    groupRefs: GroupRef[];
+    includeDescendants?: boolean;
+} | {
+    mode: 'project';
+    projectId: string;
+};
+export interface GroupScopeMatch {
+    matched: boolean;
+    coordinationGroupId: string | null;
+    matchedGroupIds: string[];
+    reason: 'explicit' | 'shared-direct' | 'shared-effective' | 'project' | 'outside-scope' | 'ambiguous';
+}
+export interface GroupedEntityReference {
+    model: string;
+    id: string;
+    commitSha?: string;
+}
+export interface GroupedContentFields {
+    groupIds: string[];
+    entityRefs?: GroupedEntityReference[];
+}