@wardby/cli 0.2.1 → 0.3.0

package/dist/generated/prisma/client.d.ts

@@ -130,6 +130,17 @@ export type CodingAgentProfile = Prisma.CodingAgentProfileModel;
  * one coding run. Policy is copied from the profile before work starts.
  */
 export type CodingRun = Prisma.CodingRunModel;
+/**
+ * Model CodingService
+ * Coding-run services (docs/coding-services.md): the catalog a repository's
+ * .wardby/services.yaml names entries from. Admin-managed over MCP
+ * (list/get_service: agents:read; create/update/delete_service:
+ * services:manage, audit-logged).
+ * Built-in rows ship with wardby, seeded by migration, and change only with a
+ * wardby release. `kind` is "sidecar" (a fresh instance in each run's pod);
+ * "external" is reserved.
+ */
+export type CodingService = Prisma.CodingServiceModel;
 /**
  * Model CodingProxySession
  * Trusted-boundary state for one coding run. Only a capability digest and an
@@ -142,6 +153,43 @@ export type CodingProxySession = Prisma.CodingProxySessionModel;
  * crash or truncated provider stream can never create new spendable budget.
  */
 export type CodingProxyRequest = Prisma.CodingProxyRequestModel;
+/**
+ * Model RegistryAllowance
+ * One package a run's profile has approved from a given ecosystem, resolved
+ * once at dispatch (see CodingRun.packageAllowlist) and used to gate every
+ * proxy fetch for the run's lifetime.
+ */
+export type RegistryAllowance = Prisma.RegistryAllowanceModel;
+/**
+ * Model RegistryFetch
+ * Audit ledger of every package fetch the registry proxy served or refused
+ * for a run.
+ */
+export type RegistryFetch = Prisma.RegistryFetchModel;
+/**
+ * Model RegistryVersionFact
+ * Immutable facts about one published package version, read from the
+ * registry itself (never from a lockfile) by lockfile verification: its
+ * publish time, integrity, download URL and declared dependencies
+ * ([{ key, name, range }], aliases resolved). Stored once and reused
+ * forever; allow/deny decisions are never cached here.
+ */
+export type RegistryVersionFact = Prisma.RegistryVersionFactModel;
+/**
+ * Model RegistryApprovedVersion
+ * One exact package version a run's lockfile plan (POST
+ * /registry/<ecosystem>/-/plan) verified and approved: a download of it is
+ * served directly, integrity-checked against this value.
+ */
+export type RegistryApprovedVersion = Prisma.RegistryApprovedVersionModel;
+/**
+ * Model RegistryPlanRefusal
+ * One exact package version a run's lockfile plan refused for a reason
+ * intrinsic to the registry's name@version (too new, an advisory, not
+ * published, no integrity, hosted elsewhere): a download of it is answered
+ * from here with the same code and reason, without a graph walk.
+ */
+export type RegistryPlanRefusal = Prisma.RegistryPlanRefusalModel;
 /**
  * Model SchedulerLease
  * Phase 2: single-row-per-scope lease so exactly one scheduler process
@@ -155,6 +203,16 @@ export type SchedulerLease = Prisma.SchedulerLeaseModel;
  * Created on first sight (find-or-create by subject).
  */
 export type Principal = Prisma.PrincipalModel;
+/**
+ * Model ResourceGrant
+ * Explicit sharing of one resource with one grantee (docs/private/
+ * 2026-09-26-resource-sharing-grants-spec-and-plan.md). Polymorphic on
+ * (resourceType, resourceId) -- no FK to the resource, so every resource
+ * delete path removes its grants in the same transaction. Levels are
+ * ordered per type and validated in code (core/grants.ts), like
+ * AgentRepository.provider, so a new type or level needs no enum migration.
+ */
+export type ResourceGrant = Prisma.ResourceGrantModel;
 /**
  * Model Task
  *
@@ -245,3 +303,45 @@ export type OAuthFamily = Prisma.OAuthFamilyModel;
  *
  */
 export type AuthRateLimit = Prisma.AuthRateLimitModel;
+/**
+ * Model AgentRepository
+ * Which repositories on which code-review host a native agent may act on,
+ * and which host events trigger it. See
+ * docs/private/2026-09-25-code-review-host-design.md §4.1.
+ */
+export type AgentRepository = Prisma.AgentRepositoryModel;
+/**
+ * Model RunHostCheck
+ * The host check a run owns, so the review tool can complete it and the
+ * run finalizer can close it if the run ends without publishing.
+ */
+export type RunHostCheck = Prisma.RunHostCheckModel;
+/**
+ * Model RunHostStatus
+ * De-duplicates host webhook redeliveries; pruned after 7 days.
+ * The status comment wardby posts on the issue or pull request whose
+ * @-mention started this run ("working on it"), edited with the outcome
+ * when the run ends. One per mention run.
+ */
+export type RunHostStatus = Prisma.RunHostStatusModel;
+/**
+ * Model HostEventDelivery
+ *
+ */
+export type HostEventDelivery = Prisma.HostEventDeliveryModel;
+/**
+ * Model HostIdentity
+ * A principal's verified identity on a code-review host (GitHub today),
+ * linked through the host's user-authorization flow (link_host_account).
+ * Only the numeric user id and login are stored, never a user token. A host
+ * user belongs to at most one principal.
+ */
+export type HostIdentity = Prisma.HostIdentityModel;
+/**
+ * Model HostIdentityLinkRequest
+ * An in-flight host identity link (link_host_account): the OAuth state and
+ * PKCE verifier, then, after the host's callback, the verified user and the
+ * hash of the one-time confirmation code the same principal must submit.
+ * Lives 10 minutes.
+ */
+export type HostIdentityLinkRequest = Prisma.HostIdentityLinkRequestModel;

package/dist/generated/prisma/commonInputTypes.d.ts

@@ -373,6 +373,21 @@ export type EnumCodingProxyRequestStatusWithAggregatesFilter<$PrismaModel = neve
     _min?: Prisma.NestedEnumCodingProxyRequestStatusFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumCodingProxyRequestStatusFilter<$PrismaModel>;
 };
+export type EnumRegistryFetchOutcomeFilter<$PrismaModel = never> = {
+    equals?: $Enums.RegistryFetchOutcome | Prisma.EnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    in?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel> | $Enums.RegistryFetchOutcome;
+};
+export type EnumRegistryFetchOutcomeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.RegistryFetchOutcome | Prisma.EnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    in?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumRegistryFetchOutcomeWithAggregatesFilter<$PrismaModel> | $Enums.RegistryFetchOutcome;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel>;
+};
 export type EnumTaskKindFilter<$PrismaModel = never> = {
     equals?: $Enums.TaskKind | Prisma.EnumTaskKindFieldRefInput<$PrismaModel>;
     in?: $Enums.TaskKind[] | Prisma.ListEnumTaskKindFieldRefInput<$PrismaModel>;
@@ -762,6 +777,21 @@ export type NestedEnumCodingProxyRequestStatusWithAggregatesFilter<$PrismaModel
     _min?: Prisma.NestedEnumCodingProxyRequestStatusFilter<$PrismaModel>;
     _max?: Prisma.NestedEnumCodingProxyRequestStatusFilter<$PrismaModel>;
 };
+export type NestedEnumRegistryFetchOutcomeFilter<$PrismaModel = never> = {
+    equals?: $Enums.RegistryFetchOutcome | Prisma.EnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    in?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel> | $Enums.RegistryFetchOutcome;
+};
+export type NestedEnumRegistryFetchOutcomeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.RegistryFetchOutcome | Prisma.EnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    in?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    notIn?: $Enums.RegistryFetchOutcome[] | Prisma.ListEnumRegistryFetchOutcomeFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedEnumRegistryFetchOutcomeWithAggregatesFilter<$PrismaModel> | $Enums.RegistryFetchOutcome;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel>;
+    _max?: Prisma.NestedEnumRegistryFetchOutcomeFilter<$PrismaModel>;
+};
 export type NestedEnumTaskKindFilter<$PrismaModel = never> = {
     equals?: $Enums.TaskKind | Prisma.EnumTaskKindFieldRefInput<$PrismaModel>;
     in?: $Enums.TaskKind[] | Prisma.ListEnumTaskKindFieldRefInput<$PrismaModel>;

package/dist/generated/prisma/enums.d.ts

@@ -19,6 +19,7 @@ export declare const RunTrigger: {
     readonly scheduled: "scheduled";
     readonly webhook: "webhook";
     readonly subagent: "subagent";
+    readonly host_event: "host_event";
 };
 export type RunTrigger = (typeof RunTrigger)[keyof typeof RunTrigger];
 export declare const CodingProxySessionStatus: {
@@ -33,6 +34,11 @@ export declare const CodingProxyRequestStatus: {
     readonly uncertain: "uncertain";
 };
 export type CodingProxyRequestStatus = (typeof CodingProxyRequestStatus)[keyof typeof CodingProxyRequestStatus];
+export declare const RegistryFetchOutcome: {
+    readonly served: "served";
+    readonly refused: "refused";
+};
+export type RegistryFetchOutcome = (typeof RegistryFetchOutcome)[keyof typeof RegistryFetchOutcome];
 export declare const TaskKind: {
     readonly run: "run";
     readonly tool_authoring: "tool_authoring";

package/dist/generated/prisma/enums.js

@@ -25,7 +25,8 @@ export const RunTrigger = {
     manual: 'manual',
     scheduled: 'scheduled',
     webhook: 'webhook',
-    subagent: 'subagent'
+    subagent: 'subagent',
+    host_event: 'host_event'
 };
 export const CodingProxySessionStatus = {
     active: 'active',
@@ -37,6 +38,10 @@ export const CodingProxyRequestStatus = {
     released: 'released',
     uncertain: 'uncertain'
 };
+export const RegistryFetchOutcome = {
+    served: 'served',
+    refused: 'refused'
+};
 export const TaskKind = {
     run: 'run',
     tool_authoring: 'tool_authoring'

package/dist/generated/prisma/internal/class.d.ts

@@ -249,6 +249,17 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get codingRun(): Prisma.CodingRunDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.codingService`: Exposes CRUD operations for the **CodingService** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingServices
+      * const codingServices = await prisma.codingService.findMany()
+      * ```
+      */
+    get codingService(): Prisma.CodingServiceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
     /**
      * `prisma.codingProxySession`: Exposes CRUD operations for the **CodingProxySession** model.
       * Example usage:
@@ -271,6 +282,61 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get codingProxyRequest(): Prisma.CodingProxyRequestDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.registryAllowance`: Exposes CRUD operations for the **RegistryAllowance** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryAllowances
+      * const registryAllowances = await prisma.registryAllowance.findMany()
+      * ```
+      */
+    get registryAllowance(): Prisma.RegistryAllowanceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryFetch`: Exposes CRUD operations for the **RegistryFetch** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryFetches
+      * const registryFetches = await prisma.registryFetch.findMany()
+      * ```
+      */
+    get registryFetch(): Prisma.RegistryFetchDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryVersionFact`: Exposes CRUD operations for the **RegistryVersionFact** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryVersionFacts
+      * const registryVersionFacts = await prisma.registryVersionFact.findMany()
+      * ```
+      */
+    get registryVersionFact(): Prisma.RegistryVersionFactDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryApprovedVersion`: Exposes CRUD operations for the **RegistryApprovedVersion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryApprovedVersions
+      * const registryApprovedVersions = await prisma.registryApprovedVersion.findMany()
+      * ```
+      */
+    get registryApprovedVersion(): Prisma.RegistryApprovedVersionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryPlanRefusal`: Exposes CRUD operations for the **RegistryPlanRefusal** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryPlanRefusals
+      * const registryPlanRefusals = await prisma.registryPlanRefusal.findMany()
+      * ```
+      */
+    get registryPlanRefusal(): Prisma.RegistryPlanRefusalDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
     /**
      * `prisma.schedulerLease`: Exposes CRUD operations for the **SchedulerLease** model.
       * Example usage:
@@ -293,6 +359,17 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get principal(): Prisma.PrincipalDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.resourceGrant`: Exposes CRUD operations for the **ResourceGrant** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more ResourceGrants
+      * const resourceGrants = await prisma.resourceGrant.findMany()
+      * ```
+      */
+    get resourceGrant(): Prisma.ResourceGrantDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
     /**
      * `prisma.task`: Exposes CRUD operations for the **Task** model.
       * Example usage:
@@ -458,5 +535,71 @@ export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out
     get authRateLimit(): Prisma.AuthRateLimitDelegate<ExtArgs, {
         omit: OmitOpts;
     }>;
+    /**
+     * `prisma.agentRepository`: Exposes CRUD operations for the **AgentRepository** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentRepositories
+      * const agentRepositories = await prisma.agentRepository.findMany()
+      * ```
+      */
+    get agentRepository(): Prisma.AgentRepositoryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.runHostCheck`: Exposes CRUD operations for the **RunHostCheck** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RunHostChecks
+      * const runHostChecks = await prisma.runHostCheck.findMany()
+      * ```
+      */
+    get runHostCheck(): Prisma.RunHostCheckDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.runHostStatus`: Exposes CRUD operations for the **RunHostStatus** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RunHostStatuses
+      * const runHostStatuses = await prisma.runHostStatus.findMany()
+      * ```
+      */
+    get runHostStatus(): Prisma.RunHostStatusDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostEventDelivery`: Exposes CRUD operations for the **HostEventDelivery** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostEventDeliveries
+      * const hostEventDeliveries = await prisma.hostEventDelivery.findMany()
+      * ```
+      */
+    get hostEventDelivery(): Prisma.HostEventDeliveryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostIdentity`: Exposes CRUD operations for the **HostIdentity** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostIdentities
+      * const hostIdentities = await prisma.hostIdentity.findMany()
+      * ```
+      */
+    get hostIdentity(): Prisma.HostIdentityDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostIdentityLinkRequest`: Exposes CRUD operations for the **HostIdentityLinkRequest** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostIdentityLinkRequests
+      * const hostIdentityLinkRequests = await prisma.hostIdentityLinkRequest.findMany()
+      * ```
+      */
+    get hostIdentityLinkRequest(): Prisma.HostIdentityLinkRequestDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
 }
 export declare function getPrismaClientClass(): PrismaClientConstructor;