@treeseed/sdk 0.13.0-rc.12 → 0.13.0-rc.121

package/dist/development/schemas.js

@@ -0,0 +1,204 @@
+import { z } from "zod";
+import { migrateDevelopmentRuntime, migrateDevelopmentSession } from "./session-migration.js";
+const identifier = z.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const gitCommit = z.string().regex(/^[a-f0-9]{40}$/u);
+const relativePath = z.string().min(1).max(512).refine((value) => {
+  if (value.startsWith("/") || value.includes("\\") || value.includes("\0")) return false;
+  return !value.split("/").some((part) => part === ".." || part === "");
+}, "Paths must be safe, normalized, repository-relative paths.");
+const environmentName = z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/u);
+const localAlias = z.string().regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*\.localhost$/u);
+const developmentModeSchema = z.enum(["released", "candidate", "live"]);
+const developmentTargetKindSchema = z.enum(["source-check", "package-watch", "live-web", "live-api", "rebuild-restart", "local-companion"]);
+const developmentExecutionCustodySchema = z.enum(["caller", "manager"]);
+const developmentReactionSchema = z.enum(["reload", "restart", "rebuild", "stale", "manual", "none"]);
+const developmentStatePolicySchema = z.enum(["stateless", "ephemeral", "clone", "shared-compatible"]);
+const operationSchema = z.object({
+  command: z.string().min(1).max(256),
+  args: z.array(z.string().max(4096)).max(64).default([]),
+  cwd: relativePath.optional(),
+  environment: z.record(environmentName, z.string().max(16384)).default({}),
+  timeoutSeconds: z.number().int().positive().max(86400).default(600)
+}).strict();
+const readinessSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("marker"), path: relativePath, timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("http"), path: z.string().startsWith("/"), expectedStatus: z.number().int().min(100).max(599).default(200), timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("tcp"), timeoutSeconds: z.number().int().positive().max(3600) }).strict(),
+  z.object({ kind: z.literal("process"), graceSeconds: z.number().int().nonnegative().max(600).default(2) }).strict()
+]);
+const endpointSchema = z.object({
+  id: identifier,
+  protocol: z.enum(["http", "https", "tcp"]),
+  port: z.number().int().min(1).max(65535),
+  canonicalAlias: localAlias.optional(),
+  visibility: z.enum(["host", "loopback", "private"]),
+  authentication: z.enum(["none", "application", "mtls"]).default("none")
+}).strict().superRefine((endpoint, context) => {
+  if (endpoint.visibility === "host" && !endpoint.canonicalAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["canonicalAlias"], message: "Host-visible endpoints require a canonical .localhost alias." });
+  if (endpoint.visibility !== "host" && endpoint.canonicalAlias) context.addIssue({ code: z.ZodIssueCode.custom, path: ["canonicalAlias"], message: "Only host-visible endpoints may request a canonical alias." });
+});
+const outputSchema = z.object({
+  path: relativePath,
+  mediaType: z.string().min(1).max(256),
+  completionMarker: relativePath.optional(),
+  digestAlgorithm: z.literal("sha256").default("sha256")
+}).strict();
+const dependencySchema = z.object({
+  id: identifier,
+  target: identifier,
+  capability: identifier.optional(),
+  locality: z.enum(["local", "remote", "either"]).default("either"),
+  reaction: developmentReactionSchema
+}).strict();
+const freezeSchema = z.object({
+  kind: z.enum(["npm-package", "oci-image", "archive", "executable"]),
+  operation: operationSchema,
+  artifacts: z.array(relativePath).min(1),
+  contractOperations: z.array(operationSchema).default([])
+}).strict();
+const developmentTargetSchema = z.object({
+  id: identifier,
+  kind: developmentTargetKindSchema,
+  executionCustody: developmentExecutionCustodySchema.default("caller"),
+  platforms: z.array(z.enum(["linux-amd64", "linux-arm64", "darwin-arm64", "darwin-amd64"])).min(1),
+  runtimeRequirements: z.array(z.string().min(1).max(128)).default([]),
+  sourceRoots: z.array(relativePath).min(1),
+  ignoredPaths: z.array(relativePath).default([]),
+  operations: z.object({
+    setup: operationSchema.optional(),
+    watch: operationSchema.optional(),
+    build: operationSchema.optional(),
+    start: operationSchema.optional(),
+    stop: operationSchema.optional(),
+    verify: operationSchema.optional(),
+    cleanup: operationSchema.optional()
+  }).strict(),
+  ready: readinessSchema,
+  outputs: z.array(outputSchema).default([]),
+  endpoints: z.array(endpointSchema).default([]),
+  dependencies: z.array(dependencySchema).default([]),
+  statePolicy: developmentStatePolicySchema,
+  migrationPolicy: z.enum(["none", "explicit-review", "disposable-only"]),
+  secretRefs: z.record(environmentName, identifier).default({}),
+  shutdown: z.object({ drainOperation: operationSchema.optional(), graceSeconds: z.number().int().nonnegative().max(3600).default(30), activeWorkPolicy: z.enum(["block", "drain", "cancel-authorized"]).default("block") }).strict(),
+  resources: z.object({ cpuCores: z.number().positive().optional(), memoryBytes: z.number().int().positive().optional(), diskBytes: z.number().int().positive().optional() }).strict().default({}),
+  logs: z.array(relativePath).default([]),
+  forbiddenOperations: z.array(z.string().min(1).max(128)).default([]),
+  freeze: freezeSchema.optional(),
+  promotion: z.object({ liveAdmissible: z.literal(false), candidateRequiresVerification: z.literal(true) }).strict()
+}).strict().superRefine((target, context) => {
+  const endpoints = target.endpoints.map((entry) => entry.id);
+  if (new Set(endpoints).size !== endpoints.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Development endpoint IDs must be unique." });
+  if ((target.kind === "package-watch" || target.kind === "source-check") && target.endpoints.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Source and package targets cannot own service endpoints." });
+  if (target.kind === "source-check" && (!target.operations.verify || target.operations.start || target.operations.watch)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["operations"], message: "Source-check targets require verify and cannot start a process." });
+  if (target.kind === "local-companion" && target.endpoints.some((entry) => entry.visibility !== "loopback")) context.addIssue({ code: z.ZodIssueCode.custom, path: ["endpoints"], message: "Local companions must remain loopback-only." });
+  if (target.kind !== "package-watch" && target.kind !== "source-check" && target.ready.kind === "marker") context.addIssue({ code: z.ZodIssueCode.custom, path: ["ready"], message: "Service targets require process, TCP, or HTTP readiness." });
+  if (target.executionCustody === "manager" && target.kind !== "rebuild-restart") context.addIssue({ code: z.ZodIssueCode.custom, path: ["executionCustody"], message: "Manager custody is reserved for rebuild-restart runtimes." });
+  if (target.statePolicy === "shared-compatible" && target.migrationPolicy !== "explicit-review") context.addIssue({ code: z.ZodIssueCode.custom, path: ["migrationPolicy"], message: "Shared state requires explicit migration review." });
+});
+const developmentRuntimeSchema = z.preprocess(migrateDevelopmentRuntime, z.object({
+  schemaVersion: z.literal("treeseed.development-runtime/v2"),
+  project: z.object({ id: identifier, repository: z.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/iu) }).strict(),
+  defaults: z.object({ restoreOnFailure: z.boolean().default(true) }).strict(),
+  targets: z.array(developmentTargetSchema).min(1)
+}).strict().superRefine((runtime, context) => {
+  const ids = runtime.targets.map((target) => target.id);
+  if (new Set(ids).size !== ids.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["targets"], message: "Development target IDs must be unique." });
+}));
+const repositoryClosureSchema = z.object({
+  projectId: identifier,
+  repository: z.string().min(1),
+  worktree: z.string().min(1),
+  commit: gitCommit,
+  branch: z.string().min(1).nullable(),
+  dirty: z.boolean(),
+  dirtyDigest: digest.nullable(),
+  recipeDigest: digest
+}).strict();
+const developmentSessionSchema = z.preprocess(migrateDevelopmentSession, z.object({
+  schemaVersion: z.literal("treeseed.development-session/v2"),
+  sessionId: identifier,
+  actor: z.string().min(1).max(256),
+  hostId: identifier,
+  createdAt: z.string().datetime(),
+  status: z.enum(["planning", "active", "degraded", "restoring", "suspended", "stopped"]),
+  repositories: z.array(repositoryClosureSchema),
+  targets: z.array(z.object({ projectId: identifier, targetId: identifier, mode: developmentModeSchema, generation: z.number().int().nonnegative(), health: z.enum(["pending", "ready", "degraded", "stopped"]), reaction: developmentReactionSchema.optional() }).strict()),
+  leases: z.array(z.object({ kind: z.enum(["alias", "component", "state", "secret"]), resource: z.string().min(1), acquiredAt: z.string().datetime() }).strict()),
+  restoredReceiptId: identifier.nullable(),
+  blockers: z.array(z.object({ code: identifier, message: z.string().min(1), targetId: identifier.optional() }).strict())
+}).strict());
+const developmentCandidateSchema = z.object({
+  schemaVersion: z.literal("treeseed.development-candidate/v1"),
+  candidateId: identifier,
+  sessionId: identifier,
+  createdAt: z.string().datetime(),
+  source: z.array(repositoryClosureSchema),
+  artifacts: z.array(z.object({ projectId: identifier, targetId: identifier, kind: z.enum(["npm-package", "oci-image", "archive", "executable", "contract-bundle"]), identity: z.string().min(1), digest, integrity: z.string().min(1).optional() }).strict()).min(1),
+  configurationDigest: digest,
+  dependencyGenerations: z.record(z.number().int().nonnegative()),
+  compatibilityAttestations: z.array(z.object({ contractId: z.string().min(1), digest, compatible: z.boolean(), minimumBump: z.enum(["none", "patch", "minor", "major"]) }).strict()),
+  verification: z.object({ status: z.enum(["pending", "passed", "failed"]), operations: z.array(z.string().min(1)), completedAt: z.string().datetime().nullable() }).strict(),
+  promotable: z.boolean()
+}).strict().superRefine((candidate, context) => {
+  if (candidate.source.some((source) => source.dirty) && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Candidates containing dirty source cannot be promotable." });
+  if (candidate.verification.status !== "passed" && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Only verified candidates can be promotable." });
+  if (candidate.promotable && candidate.source.some((source) => !Object.keys(candidate.dependencyGenerations).some((key) => key === source.projectId || key.startsWith(`${source.projectId}.`)))) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["dependencyGenerations"], message: "Promotable candidates must bind a completed generation for every source project." });
+  }
+});
+const releaseArtifactSchema = z.object({
+  id: identifier,
+  kind: z.enum(["npm-package", "oci-image", "archive", "executable", "sbom", "contract-bundle", "compatibility-attestation", "component-manifest", "compose", "provenance"]),
+  identity: z.string().min(1).max(2048),
+  digest,
+  mediaType: z.string().min(1).max(256),
+  size: z.number().int().nonnegative().optional()
+}).strict();
+const releaseEvidenceSchema = z.object({
+  schemaVersion: z.literal("treeseed.release-evidence/v1"),
+  candidate: z.object({
+    id: identifier,
+    receiptDigest: digest,
+    sourceCommit: gitCommit,
+    stagingRef: z.string().min(1).max(256),
+    workflowRunId: z.string().regex(/^[1-9][0-9]*$/u),
+    createdAt: z.string().datetime()
+  }).strict(),
+  packages: z.array(z.object({
+    projectId: identifier,
+    name: z.string().min(1).max(256),
+    version: z.string().min(1).max(128),
+    minimumBump: z.enum(["none", "patch", "minor", "major"])
+  }).strict()).min(1),
+  artifacts: z.array(releaseArtifactSchema).min(1),
+  contractBundles: z.array(z.object({ id: identifier, digest }).strict()).default([]),
+  compatibilityAttestations: z.array(z.object({ contractId: z.string().min(1), digest, compatible: z.literal(true), minimumBump: z.enum(["none", "patch", "minor", "major"]) }).strict()).default([]),
+  verification: z.object({
+    status: z.literal("passed"),
+    operations: z.array(z.string().min(1)).min(1),
+    completedAt: z.string().datetime()
+  }).strict()
+}).strict().superRefine((evidence, context) => {
+  const identities = evidence.artifacts.map((artifact) => artifact.identity);
+  if (new Set(identities).size !== identities.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["artifacts"], message: "Release artifact identities must be unique." });
+  for (const bundle of evidence.contractBundles) {
+    if (!evidence.artifacts.some((artifact) => artifact.kind === "contract-bundle" && artifact.digest === bundle.digest)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["contractBundles"], message: `Contract bundle ${bundle.id} is not present in artifact custody.` });
+  }
+  for (const attestation of evidence.compatibilityAttestations) {
+    if (!evidence.artifacts.some((artifact) => artifact.kind === "compatibility-attestation" && artifact.digest === attestation.digest)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["compatibilityAttestations"], message: `Compatibility attestation ${attestation.contractId} is not present in artifact custody.` });
+  }
+});
+export {
+  developmentCandidateSchema,
+  developmentExecutionCustodySchema,
+  developmentModeSchema,
+  developmentReactionSchema,
+  developmentRuntimeSchema,
+  developmentSessionSchema,
+  developmentStatePolicySchema,
+  developmentTargetKindSchema,
+  developmentTargetSchema,
+  releaseEvidenceSchema
+};

package/dist/development/session-migration.d.ts

@@ -0,0 +1,3 @@
+/** One-way normalization of pre-persistent development records. No expiry behavior survives. */
+export declare function migrateDevelopmentRuntime(value: unknown): unknown;
+export declare function migrateDevelopmentSession(value: unknown): unknown;

package/dist/development/session-migration.js

@@ -0,0 +1,25 @@
+function migrateDevelopmentRuntime(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if (record.schemaVersion !== "treeseed.development-runtime/v1") return value;
+  const defaults = record.defaults;
+  if (!defaults || typeof defaults !== "object" || Array.isArray(defaults)) return value;
+  const { leaseSeconds: retired, ...persistentDefaults } = defaults;
+  return { ...record, schemaVersion: "treeseed.development-runtime/v2", defaults: persistentDefaults };
+}
+function migrateDevelopmentSession(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if (record.schemaVersion !== "treeseed.development-session/v1") return value;
+  const { expiresAt: retired, ...persistent } = record;
+  const leases = Array.isArray(record.leases) ? record.leases.map((value2) => {
+    if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return value2;
+    const { expiresAt: retired2, ...lease } = value2;
+    return lease;
+  }) : record.leases;
+  return { ...persistent, schemaVersion: "treeseed.development-session/v2", status: record.status === "expired" ? "stopped" : record.status, leases };
+}
+export {
+  migrateDevelopmentRuntime,
+  migrateDevelopmentSession
+};

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

@@ -1,5 +1,7 @@
 import type { ControlPlaneOperationBinding, ControlPlaneOperationBody, ControlPlaneOperationOutput, ControlPlaneOperationPath, ControlPlaneOperationQuery, OAuthScope } from '../../operator-contracts/control-plane-operation.js';
 import type { ApiPrincipal } from '../../operator-contracts/oauth.js';
+import type { InputRequired } from '../../operator-contracts/mcp.js';
+import type { PublicClientSessionBinding } from '../../identity/contracts.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 {
@@ -7,13 +9,18 @@ export interface ControlPlaneServerProfile {
     label: string;
     baseUrl: string;
 }
-export interface ControlPlaneServerSession {
+export interface ControlPlaneServerSession extends PublicClientSessionBinding {
     serverId: string;
     audience: string;
     accessToken: string;
     refreshToken?: string;
     expiresAt?: string;
     principal?: ApiPrincipal | null;
+    activeTeam?: {
+        id: string;
+        slug: string;
+        name: string;
+    } | null;
 }
 export interface ControlPlaneServerRegistry {
     version: 1;
@@ -58,6 +65,7 @@ export interface ProblemDetails {
     requestId?: string;
     traceId?: string;
     fields?: Record<string, string[]>;
+    inputRequired?: InputRequired;
 }
 export interface ControlPlaneCallOptions {
     method?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';

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

@@ -67,7 +67,8 @@ function problemFrom(payload, status) {
     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
+    fields: source.fields && typeof source.fields === "object" ? source.fields : void 0,
+    inputRequired: source.inputRequired && typeof source.inputRequired === "object" ? source.inputRequired : void 0
   };
 }
 class ControlPlaneClient {
@@ -115,7 +116,8 @@ class ControlPlaneClient {
   }
   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);
+    const rawPayload = await responsePayload(response);
+    const payload = rawPayload && typeof rawPayload === "object" ? rawPayload : {};
     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) };
   }
@@ -131,8 +133,14 @@ class ControlPlaneClient {
   }
   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);
+    const rawPayload = await responsePayload(response);
+    const payload = rawPayload && typeof rawPayload === "object" ? rawPayload : {};
+    if (!response.ok) {
+      const problem = problemFrom(rawPayload, response.status);
+      problem.code = typeof payload.error === "string" ? payload.error : problem.code;
+      problem.detail = typeof payload.error_description === "string" ? payload.error_description : problem.detail;
+      throw new ControlPlaneClientError(problem.detail ?? problem.code, response.status, problem, 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) {
@@ -165,7 +173,11 @@ class ControlPlaneClient {
         code: "control_plane_response_invalid"
       }, response.headers);
     }
-    return payload;
+    const envelope = payload;
+    const etag = response.headers.get("etag");
+    const contractDigest = response.headers.get("x-treeseed-contract-digest");
+    if (!etag && !contractDigest) return envelope;
+    return { ...envelope, meta: { ...envelope.meta ?? {}, ...etag ? { etag } : {}, ...contractDigest ? { contractDigest } : {} } };
   }
 }
 export {

package/dist/graph/context-query-contracts.d.ts

@@ -23,9 +23,24 @@ export interface DeclarativeContextQuery {
         maxCharacters?: number;
     };
     tokenBudget?: number;
+    sources?: Array<{
+        scope: 'current-project' | 'team-library';
+    } | {
+        scope: 'same-team';
+        projectIds?: string[];
+        projectSlugs?: string[];
+    } | {
+        scope: 'shared-team';
+        teamId: string;
+        projectIds?: string[];
+    }>;
+    requirement?: 'required' | 'preferred';
+    priority?: number;
+    minimumBudget?: number;
+    maximumBudget?: number;
+    summarization?: 'none' | 'deterministic' | 'provider';
     format?: DeclarativeContextQueryFormat;
     filters?: Record<string, unknown>;
-    required?: boolean;
 }
 export type HandlerContextPackSource = 'agent_spec' | 'content_frontmatter' | 'work_package' | 'task_payload' | 'default_role_context';
 export interface DeclarativeContextQuerySourceRef {

package/dist/graph/context-query-contracts.js

@@ -68,6 +68,11 @@ function compileDeclarativeContextQuery(query, options = {}) {
   }
   if (query.resultLimit !== void 0 && !asPositiveInteger(query.resultLimit)) errors.push(`Context query "${id || "<unknown>"}" resultLimit must be a positive integer.`);
   if (query.tokenBudget !== void 0 && !asPositiveInteger(query.tokenBudget)) errors.push(`Context query "${id || "<unknown>"}" tokenBudget must be a positive integer.`);
+  if (query.minimumBudget !== void 0 && !asPositiveInteger(query.minimumBudget)) errors.push(`Context query "${id || "<unknown>"}" minimumBudget must be a positive integer.`);
+  if (query.maximumBudget !== void 0 && !asPositiveInteger(query.maximumBudget)) errors.push(`Context query "${id || "<unknown>"}" maximumBudget must be a positive integer.`);
+  if (query.minimumBudget !== void 0 && query.maximumBudget !== void 0 && query.minimumBudget > query.maximumBudget) errors.push(`Context query "${id || "<unknown>"}" minimumBudget cannot exceed maximumBudget.`);
+  if (query.priority !== void 0 && (!Number.isInteger(query.priority) || query.priority < 0 || query.priority > 100)) errors.push(`Context query "${id || "<unknown>"}" priority must be an integer from 0 through 100.`);
+  if (query.sources?.some((source) => source.scope === "shared-team" && !source.teamId.trim())) errors.push(`Context query "${id || "<unknown>"}" shared-team sources require a teamId.`);
   const scope = query.scope === void 0 ? void 0 : normalizeString(query.scope);
   if (scope !== void 0 && (!scope || !scope.startsWith("/"))) {
     errors.push(`Context query "${id || "<unknown>"}" scope must start with "/".`);

package/dist/guarantees/evidence-trust.d.ts

@@ -0,0 +1,32 @@
+import type { GuaranteeDiagnostic, GuaranteeVerifierResult } from './index.js';
+export interface UiEvidenceTrustInput {
+    requestedDevice: {
+        id: string;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        isMobile: boolean;
+        hasTouch: boolean;
+    };
+    actualDevice: {
+        id: string;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        isMobile: boolean;
+        hasTouch: boolean;
+    };
+    consoleErrors?: Array<{
+        message: string;
+        asserted?: boolean;
+    }>;
+    networkErrors?: Array<{
+        status?: number;
+        message: string;
+        asserted?: boolean;
+    }>;
+}
+export declare function validateUiEvidenceTrust(input: UiEvidenceTrustInput): GuaranteeDiagnostic[];
+export declare function runUiEvidenceTrustVerifier(): GuaranteeVerifierResult;

package/dist/guarantees/evidence-trust.js

@@ -0,0 +1,47 @@
+function validateUiEvidenceTrust(input) {
+  const diagnostics = [];
+  const requested = input.requestedDevice, actual = input.actualDevice;
+  if (requested.id !== actual.id || requested.viewport.width !== actual.viewport.width || requested.viewport.height !== actual.viewport.height || requested.isMobile !== actual.isMobile || requested.hasTouch !== actual.hasTouch) {
+    diagnostics.push({ severity: "error", code: "guarantee.scene_device_mismatch", message: `Requested ${requested.id}, but evidence recorded ${actual.id}.` });
+  }
+  for (const error of input.consoleErrors ?? []) if (!error.asserted) diagnostics.push({
+    severity: "error",
+    code: "guarantee.scene_unexpected_console_error",
+    message: error.message
+  });
+  for (const error of input.networkErrors ?? []) if (!error.asserted) diagnostics.push({
+    severity: "error",
+    code: "guarantee.scene_unexpected_network_error",
+    message: error.message
+  });
+  return diagnostics;
+}
+function runUiEvidenceTrustVerifier() {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const mismatch = validateUiEvidenceTrust({
+    requestedDevice: { id: "mobile_chromium", viewport: { width: 390, height: 844 }, isMobile: true, hasTouch: true },
+    actualDevice: { id: "desktop_chromium", viewport: { width: 1600, height: 900 }, isMobile: false, hasTouch: false },
+    consoleErrors: [{ message: "ReferenceError", asserted: false }],
+    networkErrors: [{ status: 500, message: "HTTP 500", asserted: false }]
+  });
+  const required = /* @__PURE__ */ new Set(["guarantee.scene_device_mismatch", "guarantee.scene_unexpected_console_error", "guarantee.scene_unexpected_network_error"]);
+  const observed = new Set(mismatch.map((entry) => entry.code));
+  const ok = [...required].every((code) => observed.has(code));
+  return {
+    schemaVersion: "treeseed.guarantee-verifier-result/v1",
+    verifierId: "@treeseed/sdk/ui-evidence-trust",
+    startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ok,
+    checks: [{
+      id: "sdk.ui.evidence-trust",
+      status: ok ? "passed" : "failed",
+      durationMs: 0,
+      diagnostics: ok ? [] : [{ severity: "error", code: "guarantee.ui_evidence_trust_incomplete", message: "UI evidence trust did not reject every invalid vector." }]
+    }]
+  };
+}
+export {
+  runUiEvidenceTrustVerifier,
+  validateUiEvidenceTrust
+};

package/dist/guarantees/index.d.ts

@@ -0,0 +1,130 @@
+export { runUiEvidenceTrustVerifier, validateUiEvidenceTrust } from './evidence-trust.js';
+export type GuaranteeRunStatus = 'passed' | 'failed' | 'skipped' | 'blocked';
+export type GuaranteeFilter = Record<string, unknown>;
+export interface GuaranteeDiagnostic {
+    severity: 'error' | 'warning' | 'info';
+    code: string;
+    message: string;
+    path?: string;
+    sourcePath?: string;
+}
+export interface GuaranteeRunStep {
+    id: string;
+    kind: string;
+    status: GuaranteeRunStatus;
+    evidence?: string[];
+    diagnostics?: GuaranteeDiagnostic[];
+    [key: string]: unknown;
+}
+export interface GuaranteePlanEntry {
+    id: string;
+    journey: string;
+    ownerPackage: string;
+    type: string;
+    subtype: string;
+    status: string;
+    gates: string[];
+    sourcePath: string;
+    selected: boolean;
+    dependency: boolean;
+    [key: string]: unknown;
+}
+export interface GuaranteePlanReport {
+    ok: boolean;
+    entries: GuaranteePlanEntry[];
+    diagnostics: GuaranteeDiagnostic[];
+    [key: string]: unknown;
+}
+export interface GuaranteeRunResult {
+    id: string;
+    journey: string;
+    ownerPackage: string;
+    type: string;
+    subtype: string;
+    status: GuaranteeRunStatus;
+    selected: boolean;
+    dependency: boolean;
+    sourcePath: string;
+    steps: GuaranteeRunStep[];
+    diagnostics: GuaranteeDiagnostic[];
+    evidence: string[];
+    [key: string]: unknown;
+}
+export interface GuaranteeRunReport {
+    runId: string;
+    environment: string;
+    startedAt: string;
+    completedAt?: string;
+    ok: boolean;
+    filter: GuaranteeFilter;
+    counts: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        blocked: number;
+        releaseBlockingFailures: number;
+    };
+    results: GuaranteeRunResult[];
+    diagnostics?: GuaranteeDiagnostic[];
+    [key: string]: unknown;
+}
+export interface ArtifactGuaranteeVerifier {
+    kind: 'artifact';
+    ownerPackage: string;
+    artifactId: string;
+    entrypoint: string;
+    exportName?: string;
+    caseId: string;
+    description?: string;
+}
+export interface CatalogOperationGuaranteeVerifier {
+    kind: 'catalogOperation';
+    ownerPackage: string;
+    operationId: string;
+    caseId: string;
+    description?: string;
+}
+export type GuaranteeVerifierDefinition = ArtifactGuaranteeVerifier | CatalogOperationGuaranteeVerifier;
+export interface GuaranteeVerifierCheck {
+    id: string;
+    status: 'passed' | 'failed';
+    durationMs: number;
+    diagnostics?: GuaranteeDiagnostic[];
+    error?: string;
+    evidence?: string[];
+}
+export interface GuaranteeVerifierResult {
+    schemaVersion: 'treeseed.guarantee-verifier-result/v1';
+    verifierId: string;
+    startedAt: string;
+    completedAt: string;
+    ok: boolean;
+    checks: GuaranteeVerifierCheck[];
+    [key: string]: unknown;
+}
+interface GuaranteeManifest {
+    id: string;
+    journey: string;
+    ownerPackage: string;
+    type: string;
+    subtype: string;
+    status: string;
+    gates: string[];
+    [key: string]: unknown;
+}
+interface LoadedGuarantee {
+    sourcePath: string;
+    relativePath: string;
+    manifest: GuaranteeManifest | null;
+}
+export declare function discoverGuarantees(input: {
+    workspaceRoot: string;
+    filter?: GuaranteeFilter;
+}): {
+    ok: boolean;
+    guarantees: LoadedGuarantee[];
+    diagnostics: GuaranteeDiagnostic[];
+    counts: {
+        total: number;
+    };
+};

package/dist/guarantees/index.js

@@ -0,0 +1,44 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { parse } from "yaml";
+import { runUiEvidenceTrustVerifier, validateUiEvidenceTrust } from "./evidence-trust.js";
+function walk(root, out = []) {
+  if (!existsSync(root)) return out;
+  for (const name of readdirSync(root)) {
+    if ([".git", "node_modules", "dist"].includes(name)) continue;
+    const path = resolve(root, name);
+    const stat = statSync(path);
+    if (stat.isDirectory()) walk(path, out);
+    else if (name.endsWith(".guarantee.yaml") || name.endsWith(".guarantee.yml")) out.push(path);
+  }
+  return out;
+}
+function discoverGuarantees(input) {
+  const diagnostics = [];
+  const guarantees = walk(resolve(input.workspaceRoot)).map((sourcePath) => {
+    try {
+      const value = parse(readFileSync(sourcePath, "utf8"));
+      const manifest = {
+        ...value,
+        id: String(value.id ?? ""),
+        journey: String(value.journey ?? value.id ?? ""),
+        ownerPackage: String(value.ownerPackage ?? ""),
+        type: String(value.type ?? ""),
+        subtype: String(value.subtype ?? ""),
+        status: String(value.status ?? "planned"),
+        gates: Array.isArray(value.gates) ? value.gates.map(String) : []
+      };
+      if (!manifest.id) throw new Error("id is required");
+      return { sourcePath, relativePath: relative(input.workspaceRoot, sourcePath).replaceAll("\\", "/"), manifest };
+    } catch (cause) {
+      diagnostics.push({ severity: "error", code: "guarantee.invalid_manifest", message: cause instanceof Error ? cause.message : "Invalid guarantee manifest.", sourcePath });
+      return { sourcePath, relativePath: relative(input.workspaceRoot, sourcePath).replaceAll("\\", "/"), manifest: null };
+    }
+  });
+  return { ok: diagnostics.every((entry) => entry.severity !== "error"), guarantees, diagnostics, counts: { total: guarantees.length } };
+}
+export {
+  discoverGuarantees,
+  runUiEvidenceTrustVerifier,
+  validateUiEvidenceTrust
+};