@wildo-ai/saas-models 1.1.4 → 1.1.6

package/dist/esm/flows-actors/human-decision.shared.schemas.d.ts

@@ -0,0 +1,627 @@
+import { ApplicationConfigVocabulary } from '../i18n/application-config-vocabulary.shared';
+import { z } from 'zod';
+import { ExecutionContext_ExecutionType } from '../runtime/execution-context.shared.schemas';
+/**
+ * What a person is being asked FOR in one field.
+ *
+ * The one named source for this vocabulary. `MetaWorkflow_ElicitationQuestionKind` in the
+ * application-creation layer is an alias of this enum rather than a second copy — the values decide
+ * how an answer is validated, so two enums that drift would mean a CHOICE accepted against the wrong
+ * option set.
+ */
+export declare enum HumanDecision_FieldKind {
+    /** Prose. The answer is whatever the person writes, trimmed, and must not be empty. */
+    FREE_TEXT = "free_text",
+    /** One of a closed set the request states. An answer outside `options` is REFUSED, never coerced. */
+    CHOICE = "choice",
+    /**
+     * Yes or no.
+     *
+     * The answer must resolve to an unambiguous affirmative or negative and is stored CANONICALLY, not
+     * as the person typed it — downstream readers compare a token rather than re-parsing prose. An
+     * answer that does not resolve ("probably") is refused rather than guessed, because these decide
+     * things: the regulated-domain screening questions are `CONFIRM`s, and one of them silently
+     * meaning "yes" is a compliance posture nobody chose. Resolution lives with the creation layer
+     * that owns the canonical vocabulary.
+     */
+    CONFIRM = "confirm"
+}
+/**
+ * What giving a particular answer MEANS for the work that is waiting.
+ *
+ * Closed, and deliberately three members rather than one per button. Hosts spell their buttons
+ * differently — accept/decline/cancel, submit/cancel, approve/deny — and a vocabulary with one
+ * member per spelling would have to grow every time a surface is added. What a reader actually needs
+ * to know is whether the waiting work proceeds, and whether it proceeds WITH the values.
+ */
+export declare enum HumanDecision_ResponseIntent {
+    /** Proceed, using the values supplied. Fields are validated and required. */
+    PROCEED_WITH_VALUES = "proceed_with_values",
+    /**
+     * Proceed WITHOUT values — the person declined to answer and the work continues on its own
+     * judgement, stating the assumption it made.
+     *
+     * This is also what a DENIAL is, and the distinction matters: denying a gated tool call does not
+     * abort the turn, it resumes it so the model can answer the refusal. Anything that ends the work
+     * is `ABORT`.
+     */
+    PROCEED_WITHOUT_VALUES = "proceed_without_values",
+    /** End the waiting work. Nothing is produced and no values are read. */
+    ABORT = "abort"
+}
+/** One thing a person is asked. `why` is the rationale a host may supply; an interview usually has none. */
+export declare const HumanDecision_FieldSchema: z.ZodObject<{
+    ref: z.ZodString;
+    question: z.ZodString;
+    kind: z.ZodEnum<typeof HumanDecision_FieldKind>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    why: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanDecision_Field = z.infer<typeof HumanDecision_FieldSchema>;
+/**
+ * The two options every TOOL APPROVAL offers (#1594 D1): approve runs the call, deny resumes the turn so the
+ * agent can answer the refusal. Shared because a client answers a tool approval in the one answer shape
+ * (`HumanDecision_Answer.optionRef`), and the option refs it may send are these and no others.
+ */
+export declare enum HumanDecision_ToolApprovalOption {
+    APPROVE = "approve",
+    DENY = "deny"
+}
+/** One answer a person may give, and what it means for the waiting work. */
+export declare const HumanDecision_ResponseOptionSchema: z.ZodObject<{
+    ref: z.ZodString;
+    label: z.ZodString;
+    intent: z.ZodEnum<typeof HumanDecision_ResponseIntent>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanDecision_ResponseOption = z.infer<typeof HumanDecision_ResponseOptionSchema>;
+/**
+ * @wildo_source:part:start saas.models.agent-work-decision-surface facet:layer:shared facet:family:flows-actors facet:audience:app-developer
+ *
+ * Where a decision on an AGENT'S PROPOSAL was taken (#1599). Only a decision on something an agent proposed is
+ * recorded as agent-work review — a clarifying question is not, or it would inflate the override rate's denominator.
+ * An actor-system question is a review only when its `HumanDecision_Request` carries `review: { surface }`.
+ */
+export declare enum AgentWorkDecisionSurface {
+    /** A person approved, edited or denied a tool call the agent proposed (the paused-turn approval). Always a proposal. */
+    TOOL_CALL_APPROVAL = "tool_call_approval",
+    /** A person answered an actor-system suspension that asked them to review the actor's work. */
+    ACTOR_REVIEW = "actor_review",
+    /** A person reviewed output an agent drafted into the application's own rows (`recordOutputReview`). */
+    OUTPUT_REVIEW = "output_review"
+}
+/**
+ * A reason code an expert gives for a correction (#1599): one value of the vocabulary the APPLICATION declared
+ * (`agentWorkReview.reasonCodes`). A code outside that vocabulary is refused before anything moves, never stored.
+ *
+ * No `.` (#1921): a code is also the last segment of its label key, `system_enums.AgentWorkReasonCode.<code>`, and
+ * the label tree is addressed by dotted path — a dotted code would name a label nobody could resolve, so it would
+ * render as its raw code forever with nothing reporting why.
+ */
+export declare const AgentWorkReasonCodeSchema: z.ZodString;
+/**
+ * The NAMED VOCABULARY the reason codes' words live under (#1921): `system_enums.AgentWorkReasonCode.<code>`.
+ *
+ * The VALUES are the application's (`agentWorkReview.reasonCodes`); the NAME is the framework's, so a reviewer surface
+ * and the labelling pipeline agree on where each code's words are without either inventing them. The pipeline plans one
+ * key per declared code; a code with no authored word renders as the code itself — a missing label that looks missing.
+ */
+export declare const AGENT_WORK_REASON_CODE_VOCABULARY = ApplicationConfigVocabulary.AGENT_WORK_REASON_CODE;
+/** @wildo_source:part:end saas.models.agent-work-decision-surface */
+/**
+ * Something is waiting for a person.
+ *
+ * Projected by whichever host owns the suspended work; never persisted by this layer.
+ */
+export declare const HumanDecision_RequestSchema: z.ZodObject<{
+    decisionId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        question: z.ZodString;
+        kind: z.ZodEnum<typeof HumanDecision_FieldKind>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        why: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    options: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        label: z.ZodString;
+        intent: z.ZodEnum<typeof HumanDecision_ResponseIntent>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    requestedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    review: z.ZodOptional<z.ZodObject<{
+        surface: z.ZodEnum<typeof AgentWorkDecisionSurface>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type HumanDecision_Request = z.infer<typeof HumanDecision_RequestSchema>;
+/** What a person answered. */
+export declare const HumanDecision_AnswerSchema: z.ZodObject<{
+    decisionId: z.ZodString;
+    optionRef: z.ZodString;
+    values: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type HumanDecision_Answer = z.infer<typeof HumanDecision_AnswerSchema>;
+/** Refused because the answer does not settle the request it names. */
+export declare class HumanDecisionAnswerError extends Error {
+}
+/**
+ * Check an answer against the request it claims to settle, and return the values by ref.
+ *
+ * Refuses rather than coerces, at every branch, for the reason the CONFIRM doc gives: these answers
+ * decide things, and a silently-accepted wrong one becomes the record. `CONFIRM` resolution is NOT
+ * done here — this layer does not own the canonical affirmative/negative vocabulary — so a CONFIRM
+ * field is validated as non-empty and the creation layer canonicalises it.
+ *
+ * Note what is deliberately NOT validated: an option this request never offered is refused, but the
+ * INTENT is trusted, because the host authored both the option and its meaning.
+ */
+export declare function resolveHumanDecisionAnswer(request: HumanDecision_Request, answer: HumanDecision_Answer): {
+    readonly option: HumanDecision_ResponseOption;
+    readonly values: Readonly<Record<string, string>>;
+};
+/** @wildo_source:part:start saas.models.flows-actors.human-decision-vocabulary facet:layer:shared facet:family:flows-actors facet:audience:app-developer */
+/**
+ * How a pending decision ended. The ONE vocabulary every outcome column, audit event and record reads
+ * from — the conversational release, the lapse sweep, a withdrawn task, the actor-plane resume.
+ *
+ * `LAPSED` is not a refusal. Nobody said no; nobody answered in time. A report that counts it as
+ * `REJECTED` overstates how often reviewers refuse agents, which is exactly the figure an auditor asks
+ * for, so the two stay distinct members rather than one "not approved".
+ */
+export declare enum HumanDecision_Outcome {
+    /** A person approved, unchanged. */
+    ACCEPTED = "accepted",
+    /** A person approved after changing what was proposed. Which arguments changed is recorded by NAME only. */
+    ACCEPTED_WITH_MODIFICATIONS = "accepted_with_modifications",
+    /** A person declined, or ended the waiting work. */
+    REJECTED = "rejected",
+    /** Nobody answered before `expiresAt`. Written only by the expiry path, never by an answer. */
+    LAPSED = "lapsed",
+    /** The waiting work was withdrawn (a cancelled task, an aborted run) before anyone answered. */
+    WITHDRAWN = "withdrawn",
+    /**
+     * A person answered, but the authority the work was raised under no longer holds (a revoked
+     * membership, a disabled credential, a revoked delegation). The work did NOT run: approving an
+     * action nobody may now perform is not an approval of anything.
+     */
+    REQUESTER_AUTHORITY_LAPSED = "requester_authority_lapsed"
+}
+/** @wildo_source:part:end saas.models.flows-actors.human-decision-vocabulary */
+/**
+ * The outcome an ANSWER produces. Pure; the system outcomes (LAPSED, WITHDRAWN,
+ * REQUESTER_AUTHORITY_LAPSED) are never derived from an answer and are written by their own paths.
+ *
+ * `modified` is the host's judgement that the approved values differ from the proposal — the host
+ * holds both, this layer does not.
+ */
+export declare function humanDecisionOutcomeOf(request: HumanDecision_Request, answer: HumanDecision_Answer, options: {
+    readonly modified: boolean;
+}): HumanDecision_Outcome;
+/**
+ * Which suspension mechanism holds a decision. Both describe it with the same request, route and
+ * requester; only how the waiting work resumes differs, so an audit row says which to look in.
+ */
+export declare enum HumanDecision_Plane {
+    /** A conversational turn paused on an approval-gated tool (`pausedApproval` on the execution row). */
+    CONVERSATIONAL = "conversational",
+    /** An actor-system execution suspended on a person (`suspension` on the actor execution row). */
+    ACTOR_SYSTEM = "actor_system",
+    /**
+     * A client organization's approval of one expert a service firm assigned to it (#1612). The waiting work is the
+     * firm's ASSIGNMENT (`serviceEngagementAssignments`, status `PENDING_CLIENT_APPROVAL`), which holds the decision id
+     * and is settled by a compare-and-swap on it; the route is always the client's administrator ROLE, derived from the
+     * row rather than stored beside it. No agent is involved, so audit rows name the assignment as `executionId`.
+     */
+    SERVICE_PROVIDER_EXPERT_ADMISSION = "service_provider_expert_admission"
+}
+/** @wildo_source:part:start saas.models.flows-actors.human-decision-vocabulary facet:layer:shared facet:family:flows-actors facet:audience:app-developer */
+/** Who a pending decision is routed to. */
+export declare enum HumanDecision_RouteKind {
+    /** The person whose turn raised it. Cannot be reassigned, claimed or escalated. */
+    OWNER = "owner",
+    /** One named person, who must hold the route's eligible role. Set by a declared resolver, a claim, a reassignment or an escalation. */
+    ASSIGNEE = "assignee",
+    /** Anyone holding the eligible role in the decision's organization (or in a unit containing the decision's unit). */
+    ROLE = "role"
+}
+/** @wildo_source:part:end saas.models.flows-actors.human-decision-vocabulary */
+/** What kind of principal the waiting work was raised under — the authority it resumes under. */
+export declare enum HumanDecision_RequesterKind {
+    /** A person, first-party. */
+    USER = "user",
+    /** A background principal (#1611's autonomous entry point). Never routed to OWNER: a machine answers nothing. */
+    MACHINE = "machine",
+    /** A person acting through an external OAuth client they delegated to. Resumes only while the delegation holds. */
+    DELEGATED_CLIENT = "delegated_client"
+}
+/** What a person is attempting to do to a pending decision. */
+export declare enum HumanDecision_Act {
+    ANSWER = "answer",
+    /** Move it to someone else. An answerer may, and so may a holder of the org-admin anchor role (supervisor takeover). */
+    REASSIGN = "reassign",
+    /** Take a ROLE-routed decision for yourself. */
+    CLAIM = "claim",
+    /** Give a claimed decision back to its role. */
+    UNCLAIM = "unclaim",
+    /** Move it up — to the gate's declared `escalateTo`, or a target the escalator names. Never a denial. */
+    ESCALATE = "escalate",
+    /**
+     * Stop the decision's CLAIM and DECISION clocks while the reviewer waits on something outside their
+     * control, naming one of the gate's declared pause states (#1628). Never stops the lapse: a paused
+     * decision still ends LAPSED when its window closes.
+     */
+    PAUSE_CLOCK = "pause_clock",
+    /** Restart the CLAIM and DECISION clocks; the paused time is added to both deadlines. */
+    RESUME_CLOCK = "resume_clock"
+}
+/** @wildo_source:part:start saas.models.flows-actors.review-deadline-vocabulary facet:layer:shared facet:family:flows-actors facet:audience:app-developer */
+/**
+ * The two service-target clocks of a pending decision. Neither ever ends it: missing one notifies
+ * people, or moves the decision, and the decision stays exactly as answerable as it was.
+ */
+export declare enum ReviewDeadlineKind {
+    /**
+     * By when someone should have TAKEN the decision. Met by a claim or by an answer. An ASSIGNEE or
+     * OWNER route has no claim act, so there it is met only by the answer and acts as a first reminder:
+     * being assigned a task is not the same as having started it (WS-HumanTask's start deadline).
+     */
+    CLAIM = "claim",
+    /** By when someone should have ANSWERED it. Always earlier than the lapse. */
+    DECISION = "decision"
+}
+/**
+ * The finite points at which a decision's deadlines fire. Each fires AT MOST ONCE per decision, across
+ * every host running the sweep: its own marker is written by a compare-and-swap, and only the writer
+ * that won runs the stage's actions.
+ */
+export declare enum ReviewDeadlineStage {
+    /** Before the CLAIM deadline, by the gate's `claim.warnBefore`. Armed only when that is declared. */
+    CLAIM_WARNING = "claim_warning",
+    /** The CLAIM deadline passed with nobody having taken the decision. */
+    CLAIM_MISSED = "claim_missed",
+    /** Before the DECISION deadline, by the gate's `decision.warnBefore`. Armed only when that is declared. */
+    DECISION_WARNING = "decision_warning",
+    /** The DECISION deadline passed with nobody having answered. */
+    DECISION_MISSED = "decision_missed"
+}
+/**
+ * What a stage does when it fires — the two escalation actions WS-HumanTask defines, and nothing
+ * else. There is no action that answers: a deadline can never approve, and never reject.
+ */
+export declare enum ReviewEscalationActionKind {
+    /** Tell the people who may answer it (and, at a DECISION stage, the gate's owner) that it is waiting. */
+    NOTIFY = "notify",
+    /**
+     * Move the decision to the rule's declared target, who must be able to answer it. Opt-in per gate and
+     * never inferred; a target that cannot be resolved or may not answer falls back to NOTIFY, recorded.
+     */
+    REASSIGN = "reassign"
+}
+/** How a service-target deadline counts time. The lapse always counts ELAPSED time. */
+export declare enum ReviewClockBasis {
+    /** Wall-clock time, 24/7. The default. */
+    ELAPSED = "elapsed",
+    /**
+     * Only the working hours of the application's declared `reviewCalendar`. A gate asking for it in an
+     * application that declares no calendar is refused at startup, never silently treated as ELAPSED.
+     */
+    CALENDAR = "calendar"
+}
+/** Whether a service-target deadline was met, recorded on the decision's RESOLVED event. */
+export declare enum ReviewDeadlineOutcome {
+    MET = "met",
+    MISSED = "missed"
+}
+/**
+ * Who changed a decision's route. Carried on `HUMAN_DECISION_REASSIGNED`, so a reassignment an
+ * escalation rule made is never read as one a person chose.
+ */
+export declare enum HumanDecision_RouteChangeTrigger {
+    /** A person reassigned it (an answerer handing it over, or a supervisor taking it over). */
+    PERSON = "person",
+    /** A deadline stage's REASSIGN rule moved it. The actor is the application. */
+    ESCALATION_RULE = "escalation_rule"
+}
+/** @wildo_source:part:end saas.models.flows-actors.review-deadline-vocabulary */
+/** Why an act was refused. Recorded on the `HUMAN_DECISION_ANSWER_REFUSED` event, so it is a closed vocabulary. */
+export declare enum HumanDecision_RefusalReason {
+    /** Only a signed-in person may act on a decision; a machine, a public caller or the system may not. */
+    NOT_A_USER_PRINCIPAL = "not_a_user_principal",
+    /** OWNER route: the actor is not the person whose turn raised it. */
+    NOT_THE_REQUESTER = "not_the_requester",
+    /** ASSIGNEE route: the actor is not the assignee. */
+    NOT_THE_ASSIGNEE = "not_the_assignee",
+    /** The actor does not hold the eligible role in the decision's organization or unit. */
+    ELIGIBLE_ROLE_NOT_HELD = "eligible_role_not_held",
+    /** Separation of duties: under a non-OWNER route, the requester may never act on their own decision. */
+    REQUESTER_MAY_NOT_ACT = "requester_may_not_act",
+    /** An OWNER route is fixed: it cannot be reassigned, claimed, unclaimed or escalated. */
+    OWNER_ROUTE_IS_FIXED = "owner_route_is_fixed",
+    /** CLAIM on a decision that is not an unclaimed ROLE route. */
+    NOT_CLAIMABLE = "not_claimable",
+    /** UNCLAIM on a decision nobody claimed from a role. */
+    NOT_CLAIMED = "not_claimed",
+    /** The route names no organization, so no role can be matched. The pause should have been refused. */
+    ROUTE_HAS_NO_ORGANIZATION = "route_has_no_organization",
+    /** A MACHINE requester on an OWNER route: nobody can answer it. The pause should have been refused. */
+    NOBODY_CAN_ANSWER = "nobody_can_answer",
+    /** An act this build does not know — a stale client. Refused, never guessed. */
+    UNKNOWN_ACT = "unknown_act",
+    /**
+     * A reassignment named nobody, or an escalation found no target: the gate declares no `escalateTo` and
+     * the escalator named none. A move is never a denial, so a move with nowhere to go leaves the decision
+     * exactly where it was.
+     */
+    NO_TARGET = "no_target",
+    /** PAUSE_CLOCK on a decision whose clocks are already paused. */
+    CLOCK_ALREADY_PAUSED = "clock_already_paused",
+    /** RESUME_CLOCK on a decision whose clocks are running. */
+    CLOCK_NOT_PAUSED = "clock_not_paused",
+    /** PAUSE_CLOCK naming a pause state the gate does not declare. */
+    PAUSE_STATE_NOT_DECLARED = "pause_state_not_declared",
+    /**
+     * An act this decision's plane does not offer. An expert-admission approval (#1612) is routed to the client's
+     * administrators as a ROLE and never to a named person, so it cannot be claimed, reassigned or escalated, and it
+     * arms no clocks to pause.
+     */
+    ACT_NOT_OFFERED = "act_not_offered"
+}
+/**
+ * Who may settle a pending decision. Stored on the row that holds the resume compare-and-swap, never
+ * beside it (#1360: a second store lets a reassignment and an answer both win).
+ */
+export declare const HumanDecision_RouteSchema: z.ZodObject<{
+    kind: z.ZodEnum<typeof HumanDecision_RouteKind>;
+    eligibleRole: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationUnitId: z.ZodOptional<z.ZodString>;
+    assigneeUserId: z.ZodOptional<z.ZodString>;
+    claimedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanDecision_Route = z.infer<typeof HumanDecision_RouteSchema>;
+/** The authority the waiting work was raised under, and resumes under. */
+export declare const HumanDecision_RequesterSchema: z.ZodObject<{
+    kind: z.ZodEnum<typeof HumanDecision_RequesterKind>;
+    ref: z.ZodString;
+    clientId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanDecision_Requester = z.infer<typeof HumanDecision_RequesterSchema>;
+/**
+ * How a decision ENDED, written in the same statement that ends the wait (#1594 I4) — so a crash after
+ * that statement still leaves who decided what. The conversational plane spreads these facts over its
+ * own columns (`decidedByUserId`, `decisionOutcome`…); the actor plane carries this object on the status
+ * change that took the run out of waiting.
+ */
+export declare const HumanDecision_ResolutionSchema: z.ZodObject<{
+    decisionRef: z.ZodString;
+    outcome: z.ZodEnum<typeof HumanDecision_Outcome>;
+    decidedByUserId: z.ZodOptional<z.ZodString>;
+    decidedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type HumanDecision_Resolution = z.infer<typeof HumanDecision_ResolutionSchema>;
+/**
+ * What the backend resolved about the actor's roles IN THE DECISION'S ORGANIZATION, at the moment they
+ * act — never from a connection-time snapshot. The predicate reads nothing else, which is what keeps it
+ * pure and testable as a table.
+ */
+export interface HumanDecision_RoleFacts {
+    /** Holds the route's eligible role organization-wide (directly or through the role hierarchy). */
+    readonly holdsEligibleRoleOrgWide: boolean;
+    /**
+     * Every organization unit the eligible role is held for, EXPANDED to the units those contain. The
+     * backend owns the unit tree; the predicate only asks membership.
+     */
+    readonly eligibleRoleCoveredUnitIds: readonly string[];
+    /** Holds the organization's administrative anchor role — what a supervisor takeover (REASSIGN) needs. */
+    readonly holdsOrgAdminAnchor: boolean;
+}
+/** The person attempting the act. Only a signed-in person (`USER_REQUEST`) may act. */
+export interface HumanDecision_Actor {
+    readonly executionType: ExecutionContext_ExecutionType;
+    readonly userId?: string;
+}
+/**
+ * Whether the predicate admitted the act. A named discriminant rather than an `allowed` boolean: the
+ * backend packages compile with `strict: false`, where a boolean-literal discriminant narrows nothing,
+ * so `if (!verdict.allowed) verdict.reason` would not type-check at the doors that need the reason.
+ */
+export declare enum HumanDecision_VerdictKind {
+    ALLOWED = "allowed",
+    REFUSED = "refused"
+}
+export type HumanDecision_ActVerdict = {
+    readonly kind: HumanDecision_VerdictKind.ALLOWED;
+} | {
+    readonly kind: HumanDecision_VerdictKind.REFUSED;
+    readonly reason: HumanDecision_RefusalReason;
+};
+/**
+ * May this person perform this act on this pending decision?
+ *
+ * The ONE authorization predicate for pending decisions: every door — the WebSocket answer, the REST
+ * verbs, the listing re-check, the companion's actor-plane doors, a reassignment TARGET's eligibility
+ * (I8, asked with `act: ANSWER`) — calls this and nothing else. Pure: role facts arrive pre-resolved,
+ * so it can be pinned as a truth table and cannot drift between doors.
+ *
+ * It answers WHETHER the person may act. It never lends them anything: the waiting work resumes under
+ * the REQUESTER's current authority, rebuilt at resume, so a reviewer's wider rights never reach the
+ * requester's agent.
+ */
+export declare function authorizeHumanDecisionActor(input: {
+    readonly actor: HumanDecision_Actor;
+    readonly roleFacts: HumanDecision_RoleFacts;
+    readonly route: HumanDecision_Route;
+    readonly requester: HumanDecision_Requester;
+    readonly act: HumanDecision_Act;
+}): HumanDecision_ActVerdict;
+/**
+ * What an act on a pending decision came to, as every door reports it (#1594 D6).
+ *
+ * One vocabulary for the WebSocket answer, the REST verbs and any future door, so a client branches on a
+ * name rather than on an HTTP status that means different things on different routes.
+ */
+export declare enum HumanDecision_ActOutcomeKind {
+    /** The act took effect: the decision was answered, or moved. */
+    APPLIED = "applied",
+    /**
+     * Nothing this person may act on. Deliberately ONE outcome for a decision that does not exist, one
+     * already settled, and one whose route does not admit them: telling those apart would disclose that a
+     * decision exists to someone it was not routed to.
+     */
+    NOT_ACTIONABLE = "not_actionable",
+    /** The decision's window had closed; it is now ended LAPSED. */
+    LAPSED = "lapsed",
+    /** The requester no longer holds the authority the work was raised under; it is ended and nothing ran. */
+    REQUESTER_AUTHORITY_LAPSED = "requester_authority_lapsed",
+    /** Edited arguments the tool's own schema refuses. The decision still stands and can be answered. */
+    MODIFICATION_REJECTED = "modification_rejected",
+    /**
+     * A reason code the application does not declare (`agentWorkReview.reasonCodes`, #1599). Refused before anything
+     * moves, so the decision still stands and can be answered with a declared code, or with none.
+     */
+    REASON_CODE_REJECTED = "reason_code_rejected",
+    /** The requester has not granted a purpose the resumed turn needs. The decision still stands. */
+    CONSENT_REQUIRED = "consent_required",
+    /** The person a move named may not answer this decision (I8). The decision stays where it was. */
+    TARGET_REFUSED = "target_refused",
+    /**
+     * Another answer or move landed first, so this one matched nothing. Only ever returned to someone the
+     * route admitted, who therefore already knows the decision exists.
+     */
+    SUPERSEDED = "superseded"
+}
+/** The result of one act, returned by the REST verbs. `reason` names why a refusal was refused. */
+export interface HumanDecision_ActOutcome {
+    readonly kind: HumanDecision_ActOutcomeKind;
+    readonly reason?: HumanDecision_RefusalReason;
+}
+/**
+ * The body of `POST /flows-actors/decisions/:decisionRef/:act`. Which fields mean anything depends on the
+ * act: `answer` (or `approved`) and `modifiedToolArgs` answer, `targetUserId` names who a reassignment or escalation goes
+ * to, and `reason` is the person's own words — sent to the model on an answer, never written to the trail.
+ */
+export declare const HumanDecision_ActRequestSchema: z.ZodObject<{
+    answer: z.ZodOptional<z.ZodObject<{
+        decisionId: z.ZodString;
+        optionRef: z.ZodString;
+        values: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+    modifiedToolArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    targetUserId: z.ZodOptional<z.ZodString>;
+    pauseStateRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanDecision_ActRequest = z.infer<typeof HumanDecision_ActRequestSchema>;
+/**
+ * One pending decision as the inbox shows it (#1594 D6): what is being asked, of whom, by when, and what
+ * this caller may do about it. The decision card and nothing more — never the conversation it came from
+ * (Paul, 2026-09-25: there is no "view conversation" permission).
+ */
+export interface HumanDecision_PendingCard {
+    readonly decisionRef: string;
+    readonly plane: HumanDecision_Plane;
+    /** The work that is waiting: the execution on the two agent planes, the firm's assignment on the expert-admission plane. */
+    readonly executionId: string;
+    /** The actor system the work belongs to. Empty on the expert-admission plane, which runs no actor system. */
+    readonly systemRef: string;
+    /** The gated tool. Empty on the expert-admission plane. */
+    readonly toolName: string;
+    /** The call's proposed arguments — the thing being approved. Empty on the expert-admission plane. */
+    readonly toolArgs: Record<string, unknown>;
+    /**
+     * EXPERT-ADMISSION plane only (#1612): who the client is being asked to admit. What a card needs and nothing from
+     * the client's own data — the firm, the relationship's role and scope, the expert, and who at the firm assigned them.
+     */
+    readonly serviceProviderExpertAdmission?: HumanDecision_ServiceProviderExpertAdmissionSubject;
+    /** The question itself, with the options this decision offers — present on every plane whose options are not the tool approval's two. */
+    readonly request?: HumanDecision_Request;
+    /** The tool's input schema as a serialized descriptor, when the tool can still be resolved; lets an approver edit the call. */
+    readonly toolInputSchema?: Record<string, unknown>;
+    readonly requestedAt: string;
+    readonly expiresAt?: string;
+    readonly route: HumanDecision_Route;
+    /** The version an act is checked against; a move bumps it. */
+    readonly routeVersion: number;
+    readonly requesterKind: HumanDecision_RequesterKind;
+    /** The person who raised it, for USER and DELEGATED_CLIENT requesters. */
+    readonly requesterUserId?: string;
+    /** What THIS caller may do now, computed by the same predicate every act is checked with. */
+    readonly permittedActs: readonly HumanDecision_Act[];
+    /**
+     * Whether the gate declares where an escalation goes (`escalateTo`). `permittedActs` says whether this
+     * caller MAY escalate; this says whether an escalation that names nobody has anywhere to go. Without a
+     * declared target, ESCALATE must name its target, so a surface offering a one-press Escalate shows it
+     * only when this is true — otherwise the press could only ever be refused with "no target".
+     */
+    readonly declaresEscalationTarget: boolean;
+    /**
+     * The next service-target deadline still ahead of this decision (#1628) — the CLAIM deadline until it is
+     * claimed or missed, then the DECISION deadline. Absent while the clocks are paused, and once both have
+     * passed; `expiresAt` (the lapse) is still shown then.
+     */
+    readonly nextDeadline?: {
+        readonly kind: ReviewDeadlineKind;
+        readonly dueAt: string;
+    };
+    /** Set while the clocks are paused: since when, and in which of the gate's pause states. */
+    readonly clockPause?: {
+        readonly pausedAt: string;
+        readonly pauseStateRef: string;
+    };
+    /** The pause states the gate declares — what a Pause offers. Empty: the gate cannot be paused. */
+    readonly pauseStates: readonly string[];
+    /**
+     * The reason codes an answer to THIS decision may carry (#1921): the application's `agentWorkReview.reasonCodes` when
+     * the decision reviews an agent's proposal (its settlement is an agent-work decision), and empty on a plane that is
+     * not a review of agent work — an expert admission decides who may act, not whether an agent was right. What a
+     * reviewer's reason picker offers; the answer door refuses any other code with `REASON_CODE_REJECTED`.
+     */
+    readonly reasonCodes: readonly string[];
+}
+/** The subject of an expert-admission decision card (#1612): who the client is asked to admit, and through which firm. */
+export interface HumanDecision_ServiceProviderExpertAdmissionSubject {
+    readonly relationshipId: string;
+    readonly providerOrganizationId: string;
+    /** The firm's name as the relationship snapshotted it — the client cannot read the firm's row. */
+    readonly providerOrganizationName?: string;
+    readonly expertUserId: string;
+    readonly expertName?: string;
+    readonly expertEmail?: string;
+    /** The role the relationship confers on every admitted expert. */
+    readonly role: string;
+    /** The client units the relationship is confined to; empty ⇒ organization-wide. */
+    readonly organizationUnitIds: readonly string[];
+    /** The firm administrator who assigned the expert. */
+    readonly assignedByUserId?: string;
+    readonly assignedByName?: string;
+}
+/** `GET /flows-actors/decisions`. */
+export interface HumanDecision_PendingListResponse {
+    readonly decisions: readonly HumanDecision_PendingCard[];
+}
+/** One person a decision may be reassigned or escalated to — someone who could answer it (#1594 I8). */
+export interface HumanDecision_ReassignCandidate {
+    readonly userId: string;
+    /** The membership's copy of the person's email — what a same-organization reviewer picks them by. */
+    readonly email?: string;
+}
+/**
+ * `GET /flows-actors/decisions/:decisionRef/candidates`: the people a decision may be moved to, vetted by
+ * the same predicate a move is (I8). A move to anyone else is refused anyway; listing them first is what
+ * lets a surface offer a choice instead of a free-text id.
+ */
+export interface HumanDecision_ReassignCandidatesResponse {
+    readonly candidates: readonly HumanDecision_ReassignCandidate[];
+}
+//# sourceMappingURL=human-decision.shared.schemas.d.ts.map

package/dist/esm/flows-actors/human-decision.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-decision.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/human-decision.shared.schemas.ts"],"names":[],"mappings":"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"}