agentplugged 1.0.4 → 1.2.0

package/dist/{webauthn.js → hash.js}

@@ -695,6 +695,16 @@ const EVENT_CONVERSIONS = [
 		from: 13,
 		convert: (payload) => ({ ...payload })
 	},
+	{
+		type: "checkpoint.opened",
+		from: 14,
+		convert: (payload) => ({ ...payload })
+	},
+	{
+		type: "checkpoint.opened",
+		from: 15,
+		convert: (payload) => ({ ...payload })
+	},
 	{
 		type: "creator_action.executed",
 		from: 11,
@@ -715,6 +725,26 @@ const EVENT_CONVERSIONS = [
 		from: 2,
 		convert: (payload) => ({ ...payload })
 	},
+	{
+		type: "story.merged",
+		from: 3,
+		convert: (payload) => ({ ...payload })
+	},
+	{
+		type: "story.merged",
+		from: 4,
+		convert: (payload) => ({ ...payload })
+	},
+	{
+		type: "checkpoint.web_answered",
+		from: 1,
+		convert: (payload) => ({ ...payload })
+	},
+	{
+		type: "checkpoint.web_held",
+		from: 1,
+		convert: (payload) => ({ ...payload })
+	},
 	{
 		type: "checkpoint.closed",
 		from: 1,
@@ -756,19 +786,21 @@ const EVENT_CONVERSIONS = [
 * raised when a payload gains fields a strict schema of an older engine would refuse: that
 * engine then asks for an upgrade (`UPGRADE_REQUIRED`) instead of ignoring the event as invalid.
 * `checkpoint.opened` is at 2 and at 3 and at 4
-* and at 5 and at 6 and at 7 and at 8 and at 9 and at 10 and at 11 and at 12 and at 13 and at 14, `requirement.proved` at 2, `story.merged` at 2 and at 3, `cost.reported` at 2,
+* and at 5 and at 6 and at 7 and at 8 and at 9 and at 10 and at 11 and at 12 and at 13 and at 14 and at 15 and at 16, `requirement.proved` at 2, `story.merged` at 2, at 3, at 4 and at 5, `checkpoint.web_answered` and `checkpoint.web_held` at 2, `cost.reported` at 2,
 * `creator_action.executed` at 2, at 3, at 4 and at 5 and at 6 and at 7 and at 8 and at 9 and at 10 and at 11 and at 12, `checkpoint.closed` at 2 (and `checkpoint.answered` at 2),
 * `checkpoint.elicited` and `stack.answered` at 2, `usage.measured` and
 * `agent.status_reported` at 2.
 */
 const EVENT_TYPE_VERSIONS = {
-	"checkpoint.opened": 14,
+	"checkpoint.opened": 16,
 	"checkpoint.closed": 2,
 	"checkpoint.answered": 2,
 	"cost.reported": 2,
 	"requirement.proved": 2,
 	"creator_action.executed": 12,
-	"story.merged": 3,
+	"story.merged": 5,
+	"checkpoint.web_answered": 2,
+	"checkpoint.web_held": 2,
 	"checkpoint.elicited": 2,
 	"stack.answered": 2,
 	"usage.measured": 2,
@@ -1307,16 +1339,19 @@ const MODEL_TIERS = [
 	"multimodal"
 ];
 /**
-* Clients of the model table: the AI tools as they read a sub-agent. `antigravity` and
-* `gemini-cli` are both served by the `antigravity` entry of `tools`.
+* Clients of the model table: the AI tools as they read a sub-agent.
 */
 const MODEL_CLIENT_IDS = [
 	"claude-code",
 	"codex",
 	"antigravity",
-	"gemini-cli",
 	"cursor"
 ];
+/**
+* Key of the retired Gemini CLI in a model table or in the `models` section of `method.yaml`.
+* Older products still hold it: it is read, reported and ignored, never accepted for anything new.
+*/
+const LEGACY_GEMINI_CLIENT = "gemini-cli";
 /** Model value that keeps the model of the session: no model is chosen per agent. */
 const INHERIT_MODEL = "inherit";
 const Value = z.string().trim().min(1);
@@ -1369,7 +1404,7 @@ const ModelTableSchema = z.strictObject({
 	"claude-code": tiers(ClaudeCell),
 	codex: tiers(CodexCell),
 	antigravity: tiers(ModelOnly),
-	"gemini-cli": tiers(ModelOnly),
+	[LEGACY_GEMINI_CLIENT]: z.unknown().optional(),
 	cursor: tiers(ModelOnly)
 });
 function partialTiers(cell) {
@@ -1394,7 +1429,7 @@ const ModelOverridesSchema = z.strictObject({
 		effort: z.enum([...CODEX_EFFORTS, NO_EFFORT]).optional()
 	})),
 	antigravity: partialTiers(ModelOnly.partial()),
-	"gemini-cli": partialTiers(ModelOnly.partial()),
+	[LEGACY_GEMINI_CLIENT]: z.unknown().optional(),
 	cursor: partialTiers(ModelOnly.partial())
 });
 const SemverSchema = z.string().regex(/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/);
@@ -1483,6 +1518,48 @@ const ProfileSchema = z.strictObject({
 		message: "must be empty while the code domain is inactive"
 	});
 });
+/** The starting profiles. */
+const PROFILE_PRESET_SPECS = {
+	"new-product": {
+		domains: DOMAIN_IDS,
+		phases: PHASE_IDS,
+		specialties: ["backend", "frontend"]
+	},
+	maintenance: {
+		domains: [
+			"code",
+			"quality",
+			"security",
+			"delivery",
+			"docs"
+		],
+		phases: [
+			"design",
+			"build",
+			"delivery"
+		],
+		specialties: ["backend", "frontend"]
+	},
+	"launch-only": {
+		domains: [
+			"product",
+			"creativity",
+			"marketing",
+			"sales"
+		],
+		phases: ["framing", "launch"],
+		specialties: []
+	},
+	prototype: {
+		domains: [
+			"product",
+			"ux",
+			"code"
+		],
+		phases: ["framing", "build"],
+		specialties: ["backend", "frontend"]
+	}
+};
 function idList() {
 	return z.array(SkillNameSchema).refine((list) => new Set(list).size === list.length, { message: ISSUE.duplicateValue });
 }
@@ -3590,7 +3667,7 @@ function checkpointIdOf(eventId) {
 /** A free text of 1 to `max` characters. */
 const text = (max) => z.string().trim().min(1).max(max);
 /** A short identifier: an option or a criterion. */
-const ShortIdSchema$3 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
+const ShortIdSchema$4 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
 /** A measure's name: `tests_failed`, `coverage`, `lighthouse.performance`. */
 const MetricSchema = z.string().regex(/^[a-z][a-z0-9_.]{0,63}$/, { message: "expected a lowercase name of letters, digits, dots and underscores" });
 /**
@@ -3619,13 +3696,13 @@ const CheckpointBlockSchema = z.strictObject({
 });
 /** One answer of a decision: what it is, and what it entails. */
 const CheckpointOptionSchema = z.strictObject({
-	id: ShortIdSchema$3,
+	id: ShortIdSchema$4,
 	label: text(200),
 	consequence: text(1e3)
 });
 /** A rule on a measure: `<metric> <op> <threshold>`. */
 const CheckpointCriterionSchema = z.strictObject({
-	id: ShortIdSchema$3,
+	id: ShortIdSchema$4,
 	metric: MetricSchema,
 	op: z.enum(CRITERION_OPERATORS),
 	threshold: z.number().finite(),
@@ -3633,16 +3710,38 @@ const CheckpointCriterionSchema = z.strictObject({
 });
 /** Measures reported for a checkpoint: `{ <metric>: number }`, 1 to 50 of them. */
 const MeasuresSchema = z.record(MetricSchema, z.number().finite()).refine((measures) => Object.keys(measures).length >= 1, { message: "give at least a measure" }).refine((measures) => Object.keys(measures).length <= 50, { message: "give at most 50 measures" });
+/**
+* What the creator reads first on a checkpoint, in plain words: what changes for the people who
+* use the product (`effect`), what could go wrong (`risks`) and what the agents consulted think
+* (`opinions`, one sentence each). Optional: a checkpoint without a card is read from its
+* `summary`. The fuller text stays in `summary`, one click away. `why` answers "why this?" in
+* place: one sentence for the reason, one for the alternative set aside.
+*/
+const CheckpointCardSchema = z.strictObject({
+	effect: text(300),
+	why: z.strictObject({
+		reason: text(200),
+		/** Absent when nothing else was weighed. */
+		rejected: text(200).optional()
+	}).optional(),
+	risks: z.array(text(200)).min(1).max(3).optional(),
+	opinions: z.array(z.strictObject({
+		agent: AgentIdSchema.max(64),
+		view: text(200)
+	})).min(1).max(4).optional()
+});
 /** The fields an agent gives, whose defaults `core` fixes (recipient, confirmation). */
 const describedFields = {
 	type: z.enum(CHECKPOINT_TYPES),
 	risk: z.enum(CHECKPOINT_RISKS),
 	title: text(120),
 	summary: text(2e3),
+	/** The first lines the creator reads: the effect for the users, the risks, the agents' views. */
+	card: CheckpointCardSchema.optional(),
 	documents: z.array(CheckpointDocumentSchema).max(20),
 	blocks: z.array(CheckpointBlockSchema).max(10),
 	options: z.array(CheckpointOptionSchema).min(2).max(4).optional(),
-	recommendation: ShortIdSchema$3.optional(),
+	recommendation: ShortIdSchema$4.optional(),
 	criteria: z.array(CheckpointCriterionSchema).min(1).max(20).optional(),
 	/** The phase a `phase_end` checkpoint closes: given with that type, and only with it. */
 	phase: z.enum(PHASE_IDS).optional()
@@ -3903,7 +4002,7 @@ const NOTE_REQUIRED = /* @__PURE__ */ new Set([
 const CheckpointResolvedPayloadSchema = z.strictObject({
 	checkpoint: CheckpointIdSchema,
 	decision: z.enum(RESOLUTION_DECISIONS),
-	option: ShortIdSchema$3.optional(),
+	option: ShortIdSchema$4.optional(),
 	note: text(2e3).optional(),
 	waiver_until: z.iso.datetime().optional(),
 	source: z.enum(RESOLUTION_SOURCES)
@@ -4807,6 +4906,117 @@ const QaReportedPayloadSchema = z.strictObject({
 	path: ["results"]
 });
 //#endregion
+//#region ../../packages/protocol/dist/account.js
+/**
+* The wire contract of the account routes of the relay: creating an account (the address is proved
+* by a code sent by e-mail, then a passkey is made), signing in with a passkey, reading and
+* changing the profile, signing out. No password exists anywhere in it: a passkey is the only way
+* in. The address is unique: one person, one account.
+*/
+/** The languages an account can choose. */
+const ACCOUNT_LOCALES = [
+	"fr",
+	"en",
+	"es",
+	"pt"
+];
+/** An address as the relay keeps it: trimmed and lowercased. */
+const AccountEmailSchema = z.string().transform((value) => value.trim().toLowerCase()).pipe(z.string().max(254).regex(/^[^\s@]+@[^\s@]+\.[^\s@]+$/));
+const AccountLocaleSchema = z.enum(ACCOUNT_LOCALES);
+z.strictObject({
+	email: AccountEmailSchema,
+	locale: AccountLocaleSchema
+});
+z.strictObject({
+	verification: z.string().min(1).max(64),
+	/** How long the code works, in minutes. */
+	valid_minutes: z.number().int().positive()
+});
+z.strictObject({
+	verification: z.string().min(1).max(64),
+	code: z.string().regex(new RegExp(`^[0-9]{6}$`))
+});
+z.strictObject({ verification: z.string().min(1).max(64) });
+z.strictObject({});
+z.object({
+	ceremony: z.string().min(1).max(64),
+	options: z.record(z.string(), z.unknown())
+});
+z.strictObject({
+	ceremony: z.string().min(1).max(64),
+	response: z.record(z.string(), z.unknown())
+});
+z.strictObject({ ok: z.literal(true) });
+z.strictObject({
+	ok: z.literal(true),
+	session: z.string().min(1).max(128),
+	expires_at: z.string()
+});
+z.strictObject({
+	account_id: z.string().regex(ULID_PATTERN),
+	email: z.string().nullable(),
+	locale: AccountLocaleSchema.nullable(),
+	created_at: z.string()
+});
+z.strictObject({ locale: AccountLocaleSchema });
+/** An export of the account's data, as the relay describes it to its owner. */
+const AccountExportStatusSchema = z.strictObject({
+	id: z.string().regex(ULID_PATTERN),
+	status: z.enum(["pending", "ready"]),
+	requested_at: z.string(),
+	/** The date the export is promised by (it is usually ready within seconds). */
+	due_at: z.string(),
+	ready_at: z.string().nullable(),
+	/** The date the link stops working, once the export is ready. */
+	expires_at: z.string().nullable()
+});
+z.strictObject({ export: AccountExportStatusSchema.nullable() });
+z.strictObject({ id: z.string().regex(ULID_PATTERN) });
+z.strictObject({ confirm: z.literal(true) });
+/** One passkey of the account, as its owner sees it: public facts only. */
+const AccountPasskeySchema = z.strictObject({
+	/** The credential identifier, base64url (public: it is not a secret). */
+	id: z.string().min(1).max(1024),
+	created_at: z.string(),
+	last_used_at: z.string().nullable()
+});
+z.strictObject({ passkeys: z.array(AccountPasskeySchema).max(10) });
+z.strictObject({ id: z.string().min(1).max(1024) });
+//#endregion
+//#region ../../packages/protocol/dist/account-export.js
+/**
+* The file a creator receives when they export their account: everything the relay holds about it,
+* in indented JSON, checked by this schema (`account-export.v1`). It never holds a secret and never
+* a readable content: the encrypted packets and vaults appear with their dates and sizes only, and
+* the relay cannot read them. What a product holds (documents, stories, history) lives in the
+* creator's repository and is not part of it.
+*/
+const ACCOUNT_EXPORT_SCHEMA_ID = "account-export.v1";
+const Scalar = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const Row = z.record(z.string(), Scalar);
+z.strictObject({
+	schema: z.literal(ACCOUNT_EXPORT_SCHEMA_ID),
+	generated_at: z.string(),
+	/** What is not in this file, and where it is. */
+	not_included: z.string(),
+	account: Row,
+	passkeys: z.array(Row),
+	sessions: z.array(Row),
+	devices: z.array(Row),
+	device_prekeys: z.array(Row),
+	pending_envelopes: z.array(Row),
+	seen_envelopes: z.array(Row),
+	vaults: z.array(Row),
+	shares: z.array(Row),
+	push_tokens: z.array(Row),
+	exports: z.array(Row)
+});
+//#endregion
 //#region ../../packages/protocol/dist/skill-definition.js
 /** Risk level of an agent's actions. */
 const RISK_LEVELS = [
@@ -4952,49 +5162,93 @@ const AgentOverrideSchema = z.strictObject({
 	voice: customisable.voice.optional()
 });
 //#endregion
-//#region ../../packages/protocol/dist/budget.js
-/**
-* Budgets: each story's ceiling comes from the journal (the last sprint approved that
-* holds it, or the creator's answer to a budget checkpoint); its cost from the agents' declared
-* costs (`cost.reported`, encrypted). When a declared cost reaches the alert ratio, or goes over
-* the ceiling, `core` writes `budget.threshold_reached` (no amount of cost in it), right after
-* that cost in the same write. Over the ceiling, with `on_exceed: block`, it opens a budget
-* checkpoint in between, and the story's write tools answer `BUDGET_EXCEEDED` until the creator
-* answers it.
-*/
-/** Event types of budgets, each at version 1. */
-const BUDGET_EVENT_TYPES = { thresholdReached: "budget.threshold_reached" };
-/** The thresholds a story's cost may reach: the alert ratio, then the ceiling itself. */
-const BUDGET_LEVELS = ["alert", "exceeded"];
-/** The largest ceiling, in US dollars (raising a ceiling stops there). */
-const MAX_BUDGET_USD = 1e9;
-/** The prefix of a budget checkpoint's title, before the story. */
-const BUDGET_TITLE_PREFIX = "Budget exceeded: ";
-/**
-* The source of a ceiling: the sprint (`S-…`) whose approval set it, or the budget checkpoint
-* (`G-…`) whose answer did. A threshold counts only for the ceiling it names.
-*/
-const CeilingIdSchema = z.string().regex(/^[SG]-[0-9A-HJKMNP-TV-Z]{10}$/, { message: "expected the id of a sprint (S-…) or of a checkpoint (G-…)" });
+//#region ../../packages/protocol/dist/autonomy.js
+/**
+* The autonomy dial of a product: three notches that set, in one gesture, how much the creator
+* keeps for themselves. The dial is a preset over settings the engine already has (the validation
+* level, the points the creator keeps, the installs mode, two permission rules); it adds no rule
+* of its own. Raising it never lifts a locked rule, the irreversible commands or the base guards
+* (secrets, pushes to the main branch), and never makes an agent validate for the creator:
+* the merge, the release and the publications are not touched by any notch.
+*
+* Everything here is data and pure functions: the machine writes the settings with the engine's own
+* writers, and the web view reads the same table to say what a notch changes.
+*/
+/** The notches, from the most careful to the most free. */
+const AUTONOMY_DIALS = [
+	"prudent",
+	"balanced",
+	"wide"
+];
+const AutonomyDialSchema = z.enum(AUTONOMY_DIALS);
+/** What a product's settings add up to: a notch, or `custom` (set by hand or from a terminal). */
+const AUTONOMY_DIAL_STATES = [...AUTONOMY_DIALS, "custom"];
+const AutonomyDialStateSchema = z.enum(AUTONOMY_DIAL_STATES);
+/** The points of validation the dial can hand to the agents (the others are never touched). */
+const AUTONOMY_POINTS = [
+	"framing",
+	"architecture",
+	"breakdown"
+];
 /**
-* `payload` of `budget.threshold_reached`: the level reached, the ceiling it was measured against
-* (its amount and its source, never the cost), the settings in force, and the budget checkpoint
-* opened just before it in the same write (`exceeded` under `block` only; absent when one is
-* already open).
-*/
-const BudgetThresholdReachedPayloadSchema = z.strictObject({
-	level: z.enum(BUDGET_LEVELS),
-	budget_usd: z.number().finite().min(0).max(MAX_BUDGET_USD),
-	ceiling: CeilingIdSchema,
-	alert_ratio: z.number().finite().min(MIN_ALERT_RATIO).max(1),
-	on_exceed: z.enum(BUDGET_EXCEED_MODES),
-	checkpoint: CheckpointIdSchema.optional()
-}).superRefine((value, context) => {
-	if (value.checkpoint !== void 0 && (value.level !== "exceeded" || value.on_exceed !== "block")) context.addIssue({
-		code: "custom",
-		path: ["checkpoint"],
-		message: "a checkpoint goes only with an exceeded level under block"
-	});
+* - `none`: any value.
+* - `never_allow`: `ask` or `deny` only (the commands that erase data).
+* - `locked`: `deny` only (the push to the main branch, the force push, the secrets).
+*/
+const RULE_LOCKS = {
+	read_files: "none",
+	edit_code: "none",
+	run_checks: "none",
+	install_dependency: "none",
+	internet: "none",
+	destructive_command: "never_allow",
+	push_main: "locked",
+	force_push: "locked",
+	read_secrets: "locked"
+};
+const ThresholdSchema = z.int().min(3).max(50);
+/** Rule values by action: every action has one. */
+const RuleTableSchema = z.strictObject({
+	read_files: z.enum(RULE_VALUES),
+	edit_code: z.enum(RULE_VALUES),
+	run_checks: z.enum(RULE_VALUES),
+	install_dependency: z.enum(RULE_VALUES),
+	internet: z.enum(RULE_VALUES),
+	destructive_command: z.enum(RULE_VALUES),
+	push_main: z.enum(RULE_VALUES),
+	force_push: z.enum(RULE_VALUES),
+	read_secrets: z.enum(RULE_VALUES)
+});
+/**
+* What a machine says of the autonomy of a product it serves. `dial`, `mode`, `installs`, `kept`
+* and `rules` are what the product's `method.yaml` records now. The engine reads these settings on
+* the main branch: when what is recorded is not in force yet, `in_force` says what is (the notch
+* and the rules that differ), and the web view does not pretend otherwise.
+*/
+const ProductAutonomySchema = z.strictObject({
+	dial: AutonomyDialStateSchema,
+	mode: z.enum(VALIDATION_MODES),
+	installs: z.enum(INSTALL_MODES),
+	kept: z.array(z.enum(VALIDATION_POINTS)).max(VALIDATION_POINTS.length),
+	rules: RuleTableSchema,
+	in_force: z.strictObject({
+		dial: AutonomyDialStateSchema,
+		rules: z.partialRecord(z.enum(RULE_ACTIONS), z.enum(RULE_VALUES))
+	}).optional(),
+	/** Validations without a change after which a notch is proposed. */
+	threshold: ThresholdSchema,
+	/** Per kind of point, when the creator said « not now » to the proposal. */
+	snoozed: z.partialRecord(z.enum(AUTONOMY_POINTS), z.iso.datetime()).optional()
+});
+z.strictObject({ dial: AutonomyDialSchema });
+z.strictObject({
+	action: z.enum(RULE_ACTIONS),
+	value: z.enum(RULE_VALUES)
 });
+z.strictObject({
+	snooze: z.enum(AUTONOMY_POINTS).optional(),
+	threshold: ThresholdSchema.optional()
+}).refine((params) => params.snooze !== void 0 || params.threshold !== void 0, { message: "a kind of point to put off, or a threshold" });
 //#endregion
 //#region ../../packages/protocol/dist/question-tool.js
 /**
@@ -5080,7 +5334,7 @@ const ChatProofSchema = z.strictObject({
 });
 /** The creator's words, as quoted: 1 to 4000 characters, never only blanks. */
 const QuoteSchema$1 = z.string().max(MAX_QUOTE_LENGTH).trim().min(1);
-const ShortIdSchema$2 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
+const ShortIdSchema$3 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
 /** A tool session id as a hook gives it: printable, at most 200 characters. */
 const ToolSessionIdSchema = z.string().trim().min(1).max(200).regex(/^[\x21-\x7e]+$/, { message: "expected printable characters without spaces" });
 /**
@@ -5098,7 +5352,7 @@ const AnswerCheckpointInputSchema = z.strictObject({
 	agent: AgentIdSchema.max(64),
 	checkpoint: z.string().trim().toUpperCase().pipe(CheckpointIdSchema),
 	decision: z.enum(ANSWER_DECISIONS).optional(),
-	option: ShortIdSchema$2.optional(),
+	option: ShortIdSchema$3.optional(),
 	note: z.string().trim().min(1).max(2e3).optional(),
 	quote: QuoteSchema$1.optional(),
 	session: ToolSessionIdSchema.optional(),
@@ -5159,7 +5413,7 @@ const AnswerCheckpointInputSchema = z.strictObject({
 const CheckpointAnsweredPayloadSchema = z.strictObject({
 	checkpoint: CheckpointIdSchema,
 	decision: z.enum(CHAT_DECISIONS),
-	option: ShortIdSchema$2.optional(),
+	option: ShortIdSchema$3.optional(),
 	note: z.string().trim().min(1).max(2e3).optional(),
 	source: z.literal("chat"),
 	quote: QuoteSchema$1,
@@ -5184,7 +5438,7 @@ const CheckpointAnsweredPayloadSchema = z.strictObject({
 const CheckpointAutoAppliedPayloadSchema = z.strictObject({
 	checkpoint: CheckpointIdSchema,
 	decision: z.literal("option_chosen"),
-	option: ShortIdSchema$2
+	option: ShortIdSchema$3
 });
 /**
 * `payload` of `checkpoint.reopened`: an automatic application cancelled. From the chat, it
@@ -5216,81 +5470,674 @@ const ANTICIPATED_ANSWER_WINDOW_MS = 18e5;
 /** How long the hook keeps the creator's messages, and how recent a quoted one must be. */
 const CHAT_RETENTION_MS = 864e5;
 //#endregion
-//#region ../../packages/protocol/dist/checkpoint-closed.js
+//#region ../../packages/protocol/dist/device-trust.js
 /**
-* A point closed by the engine itself: when what a checkpoint asks about is already
-* settled, nobody has to answer it. The engine writes `checkpoint.closed` with the reason, and the
-* projection checks the reason against the journal (a point that is still waiting for something is
-* never closed). The creator is never shown a point whose object is settled.
+* The devices of trust in the journal. A product's
+* registry of trusted devices is its journal: `device.paired` says "this key is trusted",
+* `device.revoked` takes it back, `device.confirmed` ends the provisional state of a device whose
+* handover is complete, `device.root_certified` records that the first phone recognised the root,
+* and `trust.dismissed` clears a `SECURITY_ROOT_CHANGED` alert. The chain of authorizations must
+* lead to the root the bridge pinned locally, outside the repository: never to an event's ULID.
+*
+* Generic on purpose: schemas and rules only, no transport, no account, no offer.
 */
-/** Event type of the closing of a checkpoint by the engine, at version 1. */
-const CHECKPOINT_CLOSED_EVENT_TYPES = { closed: "checkpoint.closed" };
-/** `payload` of `checkpoint.closed`: the checkpoint, why, and the newer one for `replaced`. */
-const CheckpointClosedPayloadSchema = z.strictObject({
-	checkpoint: CheckpointIdSchema,
-	reason: z.enum([
-		"story_merged",
-		"review_redone",
-		"replaced",
-		"step_skipped",
-		"block_lifted",
-		"worktree_gone",
-		"lapsed"
-	]),
-	/** The checkpoint that replaces it: with `replaced`, and only with it. */
-	ref: CheckpointIdSchema.optional()
-}).refine((payload) => payload.reason === "replaced" === (payload.ref !== void 0), {
-	message: "a ref goes with replaced, and only with it",
-	path: ["ref"]
-});
-//#endregion
-//#region ../../packages/protocol/dist/checkpoint-decided.js
+/** Event types of the devices of trust, each at version 1. */
+const DEVICE_TRUST_EVENT_TYPES = {
+	paired: "device.paired",
+	revoked: "device.revoked",
+	rootCertified: "device.root_certified",
+	confirmed: "device.confirmed",
+	dismissed: "trust.dismissed"
+};
 /**
-* A point decided by the agent responsible for it. The creator keeps for
-* themselves the points they chose (`validation.points` of `method.yaml`); any other point is
-* decided by an agent, which says why. The decision is written as the agent (`actor.kind: agent`,
-* signed by the machine key), never as the creator: its source and its assurance are `agent`, so
-* the history, the morning summary and every surface always tell it apart from an answer of the
-* creator, and the creator can reopen it at any time.
+* The types the engine writes as a system actor (the bridge, or a creator's terminal for the
+* first ones): refused in any write by an agent. `trust.dismissed` is the creator's (signed by
+* the creator's key).
 */
-/** Event type of a point decided by an agent, at version 1. */
-const CHECKPOINT_DECIDED_EVENT_TYPES = { decided: "checkpoint.decided" };
+const DEVICE_TRUST_SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
+	DEVICE_TRUST_EVENT_TYPES.paired,
+	DEVICE_TRUST_EVENT_TYPES.revoked,
+	DEVICE_TRUST_EVENT_TYPES.rootCertified,
+	DEVICE_TRUST_EVENT_TYPES.confirmed
+]);
+new Set(Object.values(DEVICE_TRUST_EVENT_TYPES));
+/** The kinds of device a `device.paired` registers (the creator's key has its own events). */
+const PAIRED_DEVICE_KINDS = [
+	"machine",
+	"phone",
+	"browser"
+];
+/** `machine:`, `human:`, `phone:` or `browser:` then 16 base64url characters. */
+const DEVICE_ID_PATTERN = /^(machine|human|phone|browser):[A-Za-z0-9_-]{16}$/;
+/** The identifier of a device `device.paired` registers. */
+const PAIRED_DEVICE_ID_PATTERN = /^(machine|phone|browser):[A-Za-z0-9_-]{16}$/;
+/** The identifier of a bridge. */
+const BRIDGE_ID_PATTERN = /^machine:[A-Za-z0-9_-]{16}$/;
+/** The kind of identifier (`machine`, `human`, `phone`, `browser`), or undefined when malformed. */
+function deviceKindOf(device) {
+	if (!DEVICE_ID_PATTERN.test(device)) return void 0;
+	return device.slice(0, device.indexOf(":"));
+}
+/** The algorithms of the linked devices (the `webauthn-*` ones serve the terminal's key only). */
+const DEVICE_SIG_ALG = "ed25519";
+const DEVICE_ENC_ALG = "x25519";
+/** 32 bytes in base64url: 43 characters, the last one carrying 4 bits only. */
+const PUBLIC_KEY_32 = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
+/** 16 random bytes in base64url: 22 characters, the last one carrying 2 bits only. */
+const RANDOM_16 = /^[A-Za-z0-9_-]{21}[AQgw]$/;
+/** `sha256:` then the 32-byte digest in base64url (an event's hash). */
+const TRUST_EVENT_HASH_PATTERN = /^sha256:[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
+const publicKey32 = z.string().regex(PUBLIC_KEY_32).refine(isCanonicalBase64url);
+const utcDatetime$1 = z.iso.datetime();
+/** A public key of a device with its algorithm: `{ alg, key }`. */
+const DeviceSigKeySchema = z.strictObject({
+	alg: z.literal(DEVICE_SIG_ALG),
+	key: publicKey32
+});
+const DeviceEncKeySchema = z.strictObject({
+	alg: z.literal(DEVICE_ENC_ALG),
+	key: publicKey32
+});
 /**
-* What `decide_checkpoint` may be given: a decision, or `escalate`, the agent handing the point back
-* to the creator with its reason when it cannot or should not decide it (a merge the forge refuses
-* and nobody can fix, a point it finds beyond its remit). The point then waits for the creator.
+* Every signed structure of trust carries its label `t` (type and version), and a key signs the
+* types it knows only: an authorization is never taken for an order, nor a relay's challenge for
+* an authorization. The domain separation stops a signature made for one purpose from
+* serving another.
 */
-const DECIDE_CHOICES = [...CHAT_DECISIONS, "escalate"];
-const ShortIdSchema$1 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
-const ReasonSchema$1 = z.string().trim().min(1).max(1e3);
-function checkOption(value, context) {
-	if (value.decision === "option_chosen" !== (value.option !== void 0)) context.addIssue({
-		code: "custom",
-		path: ["option"],
-		message: "an option goes with option_chosen, and only with it"
-	});
+const TRUST_SIGNATURE_TAGS = {
+	devicePaired: "device.paired.auth/v1",
+	deviceRevoked: "device.revoked.auth/v1",
+	pairOffer: "pair.offer/v1",
+	rootCertified: "device.root_certified.auth/v1",
+	message: "msg.inner/v1",
+	linkWelcome: "link.welcome/v1",
+	vaultBlob: "vault.blob/v1"
+};
+/** True for a label this engine knows. */
+function isTrustSignatureTag(tag) {
+	return Object.values(TRUST_SIGNATURE_TAGS).includes(tag);
 }
 /**
-* Input of `decide_checkpoint`: the agent that decides, the point, its decision and the reason.
-* `option` goes with `option_chosen` only.
+* The order of a trusted device that offered a pairing (`pair.offer`): one rendezvous
+* `x`, valid until `expires_at`, for one device of `kind`. The bridge writes `device.paired` on
+* its authority, once.
 */
-const DecideCheckpointInputSchema = z.strictObject({
-	agent: AgentIdSchema.max(64),
-	checkpoint: z.string().trim().toUpperCase().pipe(CheckpointIdSchema),
-	decision: z.enum(DECIDE_CHOICES),
-	option: ShortIdSchema$1.optional(),
-	reason: ReasonSchema$1
-}).superRefine(checkOption);
-/** `payload` of `checkpoint.decided`: the point, the decision and the agent's reason. */
-const CheckpointDecidedPayloadSchema = z.strictObject({
-	checkpoint: CheckpointIdSchema,
-	decision: z.enum(DECIDE_CHOICES),
-	option: ShortIdSchema$1.optional(),
-	reason: ReasonSchema$1
-}).superRefine(checkOption);
-//#endregion
-//#region ../../packages/protocol/dist/ci.js
-/**
+const PairOfferSchema = z.strictObject({
+	/** The rendezvous: 16 random bytes in base64url, or the 8-symbol address of a short code. */
+	x: z.union([z.string().regex(RANDOM_16).refine(isCanonicalBase64url), z.string().regex(/^[0-9A-HJKMNP-TV-Z]{8}$/)]),
+	expires_at: utcDatetime$1
+});
+/**
+* The proof that the creator wanted this: the signature, by a device already trusted (or by the
+* root, from the command run on the root machine), of the record of the event (`order` absent) or
+* of the signed order `pair.offer` (`order` present).
+*/
+const AuthorizationSchema = z.strictObject({
+	signer: z.string().regex(DEVICE_ID_PATTERN),
+	alg: z.literal(DEVICE_SIG_ALG),
+	sig: Ed25519SignatureSchema,
+	order: PairOfferSchema.optional()
+});
+/** `payload` of `device.paired` v1. */
+const DevicePairedPayloadSchema = z.strictObject({
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
+	kind: z.enum(PAIRED_DEVICE_KINDS),
+	sig: DeviceSigKeySchema,
+	enc: DeviceEncKeySchema,
+	/** The bridge of the perimeter: the authorization holds in the journals this bridge writes. */
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	/** True until the handover is complete (`device.confirmed`): the bridge alone may revoke it. */
+	provisional: z.boolean(),
+	issued_at: utcDatetime$1,
+	authorization: AuthorizationSchema
+}).refine((payload) => payload.device.startsWith(`${payload.kind}:`), {
+	path: ["kind"],
+	message: "the kind is the prefix of the device"
+});
+/** `payload` of `device.revoked` v1. */
+const DeviceRevokedPayloadSchema = z.strictObject({
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
+	/**
+	* For a machine that writes to the journal: the hash of its last event the author knew. The
+	* projection accepts of a revoked machine only the ancestors of this head (and of the heads of
+	* the other revocations of it). Null for a device that writes nothing.
+	*/
+	chain_head: z.string().regex(TRUST_EVENT_HASH_PATTERN).nullable(),
+	issued_at: utcDatetime$1,
+	author: z.string().regex(DEVICE_ID_PATTERN),
+	authorization: z.strictObject({
+		alg: z.literal(DEVICE_SIG_ALG),
+		sig: Ed25519SignatureSchema
+	})
+}).refine((payload) => payload.chain_head === null || payload.device.startsWith("machine:"), {
+	path: ["chain_head"],
+	message: "only a machine has a chain head"
+});
+/** `payload` of `device.root_certified` v1: the first phone recognises the root. */
+const DeviceRootCertifiedPayloadSchema = z.strictObject({
+	root: z.strictObject({
+		device: z.string().regex(DEVICE_ID_PATTERN),
+		key: publicKey32
+	}),
+	issued_at: utcDatetime$1,
+	authorization: AuthorizationSchema
+});
+/** `payload` of `device.confirmed` v1: the handover of the device is complete. */
+const DeviceConfirmedPayloadSchema = z.strictObject({
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
+	issued_at: utcDatetime$1
+});
+/** `payload` of `trust.dismissed` v1: the events (their hashes) the creator dismisses. */
+const TrustDismissedPayloadSchema = z.strictObject({
+	events: z.array(z.string().regex(TRUST_EVENT_HASH_PATTERN)).min(1).max(16),
+	issued_at: utcDatetime$1
+});
+/** The pinned root of a product, kept locally outside the repository (written by `pair`). */
+const RootPinSchema = z.strictObject({
+	device: z.string().regex(/^(machine|human):[A-Za-z0-9_-]{16}$/),
+	public_key: publicKey32
+});
+/**
+* What the authorization of a `device.paired` signs: its payload without `authorization`, plus the
+* label. Independent of the product and of `prev`: the bridge writes it in each journal it serves,
+* but cannot make one without the signer.
+*/
+function devicePairedRecord(payload) {
+	return {
+		t: TRUST_SIGNATURE_TAGS.devicePaired,
+		device: payload.device,
+		kind: payload.kind,
+		sig: payload.sig,
+		enc: payload.enc,
+		bridge: payload.bridge,
+		provisional: payload.provisional,
+		issued_at: payload.issued_at
+	};
+}
+/** What the signed order `pair.offer` covers. */
+function pairOfferRecord(input) {
+	return {
+		t: TRUST_SIGNATURE_TAGS.pairOffer,
+		kind: input.kind,
+		bridge: input.bridge,
+		x: input.order.x,
+		expires_at: input.order.expires_at
+	};
+}
+/** What the authorization of a `device.revoked` signs. */
+function deviceRevokedRecord(payload) {
+	return {
+		t: TRUST_SIGNATURE_TAGS.deviceRevoked,
+		device: payload.device,
+		chain_head: payload.chain_head,
+		issued_at: payload.issued_at,
+		author: payload.author
+	};
+}
+/** What the authorization of a `device.root_certified` signs. */
+function rootCertifiedRecord(payload) {
+	return {
+		t: TRUST_SIGNATURE_TAGS.rootCertified,
+		root: payload.root,
+		issued_at: payload.issued_at
+	};
+}
+//#endregion
+//#region ../../packages/protocol/dist/checkpoint-web.js
+/**
+* Event types of the answers given from the web view, at version 1. A reversible point's answer
+* is first held (`held`) for the length of the undo window, with the point still open for everyone;
+* then it is either taken back (`holdCancelled`) or carried out (`answered`). An answer to a point
+* that cannot be undone is carried out at once. A held answer whose carrying out the machine could
+* not do (the merge of a story that the forge refuses) is released (`holdFailed`): the point stays
+* open and says why.
+*/
+const WEB_ANSWER_EVENT_TYPES = {
+	answered: "checkpoint.web_answered",
+	held: "checkpoint.web_held",
+	holdCancelled: "checkpoint.web_hold_cancelled",
+	holdFailed: "checkpoint.web_hold_failed"
+};
+/** How long the machine holds a reversible answer before it carries it out: the creator may undo it. */
+const WEB_ANSWER_WINDOW_MS = 1e4;
+/**
+* How long after its window a held answer is still waited for. Past it, the machine did not carry
+* the answer out (it is off, or the journal refuses it): the point is open again for a new answer.
+*/
+const WEB_ANSWER_STALE_MS = 15e3;
+/** The longest note the creator types with a decision, like a resolution's note. */
+const MAX_WEB_ANSWER_NOTE_LENGTH = 2e3;
+/** Where an answer carried by a signed order came from: a browser (`web`) or a phone (`mobile`). */
+const ANSWER_SOURCES = ["web", "mobile"];
+/**
+* The source of an answer given by `device`, drawn from the kind of its identifier (a browser's
+* `browser:`, a phone's `phone:`), which the journal registered when the device was paired. Undefined
+* for any other device: a machine never answers this way.
+*/
+function answerSourceOf(device) {
+	if (device.startsWith("browser:")) return "web";
+	if (device.startsWith("phone:")) return "mobile";
+}
+const ShortIdSchema$2 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
+function checkAnswer(value, context) {
+	if (value.decision === "option_chosen" !== (value.option !== void 0)) context.addIssue({
+		code: "custom",
+		path: ["option"],
+		message: "an option goes with option_chosen, and only with it"
+	});
+	if (NOTE_REQUIRED.has(value.decision) && value.note === void 0) context.addIssue({
+		code: "custom",
+		path: ["note"],
+		message: "this decision needs a note"
+	});
+}
+z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	decision: z.enum(CHAT_DECISIONS),
+	option: ShortIdSchema$2.optional(),
+	note: z.string().trim().min(1).max(MAX_WEB_ANSWER_NOTE_LENGTH).optional()
+}).superRefine(checkAnswer);
+/** Refuses a source that is not the one the device's kind gives. */
+function checkSource(value, context) {
+	if (answerSourceOf(value.device) !== value.source) context.addIssue({
+		code: "custom",
+		path: ["source"],
+		message: "the source is the one the device's kind gives"
+	});
+}
+/**
+* `payload` of `checkpoint.web_answered`: the point, the decision, the order that carried it and
+* the browser or phone device that signed it. The assurance (`device`) is drawn from the event's
+* type by the projection, never declared; the source must be the one the device's kind gives.
+*/
+const CheckpointWebAnsweredPayloadSchema = z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	decision: z.enum(CHAT_DECISIONS),
+	option: ShortIdSchema$2.optional(),
+	note: z.string().trim().min(1).max(MAX_WEB_ANSWER_NOTE_LENGTH).optional(),
+	source: z.enum(ANSWER_SOURCES),
+	order: UlidSchema,
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN)
+}).superRefine(checkAnswer).superRefine(checkSource);
+z.strictObject({ checkpoint: CheckpointIdSchema });
+/**
+* `payload` of `checkpoint.web_held`: an answer the machine holds for `WEB_ANSWER_WINDOW_MS`. It
+* is the answer of `checkpoint.web_answered`, which the machine writes when the window is over; the
+* point stays open until then.
+*/
+const CheckpointWebHeldPayloadSchema = CheckpointWebAnsweredPayloadSchema;
+/**
+* `payload` of `checkpoint.web_hold_cancelled`: the held answer of the order `held` taken back by
+* the order `order`, signed by the browser device `device`. The point was never answered.
+*/
+const CheckpointWebHoldCancelledPayloadSchema = z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	held: UlidSchema,
+	order: UlidSchema,
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN)
+});
+/** The longest code and reason a failed carrying out records: short tokens, never a message. */
+const FAILURE_TOKEN = /^[A-Za-z][A-Za-z0-9_.]{0,47}$/;
+/**
+* `payload` of `checkpoint.web_hold_failed`: the held answer of the order `held` that the machine
+* could not carry out (`code` is the engine's error code, `reason` its short reason when it has
+* one, `merge_failed` and `head_moved` for instance). Nothing was decided and the point is open
+* again. Neither a message nor an address nor a token is recorded.
+*/
+const CheckpointWebHoldFailedPayloadSchema = z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	held: UlidSchema,
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
+	code: z.string().regex(FAILURE_TOKEN),
+	reason: z.string().regex(FAILURE_TOKEN).optional()
+});
+//#endregion
+//#region ../../packages/protocol/dist/push.js
+/**
+* Notifications without content. A notification carries an opaque identifier, a category and a
+* level of urgency, and nothing else: the relay never learns a product's name, a title or a text.
+* The machine decides what is urgent (it knows the content); the relay only forwards, to the
+* phones of the account, through the push services of the platforms.
+*/
+/** The platforms a phone can be reached on: APNs (iOS) and FCM (Android), directly. */
+const PUSH_PLATFORMS = ["ios", "android"];
+/** What a notification is about, in the words of the product (never a product's own text). */
+const NOTIFY_CATEGORIES = [
+	"decision",
+	"permission",
+	"merge"
+];
+/** How hard a notification interrupts. */
+const NOTIFY_URGENCIES = ["urgent", "normal"];
+const PushTokenSchema = z.string().min(16).max(4096).regex(/^[\x21-\x7e]+$/);
+/** The opaque identifier of a notification: 43 characters of base64url (a digest). */
+const NotifyIdSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/);
+/**
+* What a notification carries, in total. The relay builds the platform message from this and from
+* a fixed text of its own; nothing of the product is in it.
+*/
+const PushNoticeSchema = z.strictObject({
+	id: NotifyIdSchema,
+	category: z.enum(NOTIFY_CATEGORIES),
+	urgency: z.enum(NOTIFY_URGENCIES)
+});
+/** The surfaces of the creator that can be notified (the watch comes with its own app). */
+const NOTIFY_SURFACES = ["web", "mobile"];
+/** What a surface rings for: only the urgent, everything that comes back to the creator, nothing. */
+const SURFACE_CHOICES = [
+	"urgent",
+	"all",
+	"none"
+];
+/** A time zone name as the platforms give it (`Europe/Paris`): bounded, no free text. */
+const TimeZoneSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_+\-/]{0,63}$/);
+const CategoriesSchema = z.array(z.enum(NOTIFY_CATEGORIES)).max(NOTIFY_CATEGORIES.length).refine((list) => new Set(list).size === list.length, { message: "duplicate category" });
+const MinuteOfDaySchema = z.number().int().min(0).max(1439);
+/**
+* What the creator chose about notifications. It holds no product text and no content: categories,
+* hours and surfaces. The relay keeps it in clear because it applies it (it never sees more than an
+* opaque notice); the same document is shown and changed from every surface.
+*/
+const NotifyPrefsSchema = z.strictObject({
+	/** The categories that notify at all. */
+	types: CategoriesSchema,
+	/** Active on one surface: the others stay quiet. Off: each surface follows its own choice. */
+	presence: z.boolean(),
+	surfaces: z.strictObject({
+		web: z.enum(SURFACE_CHOICES),
+		mobile: z.enum(SURFACE_CHOICES)
+	}),
+	quiet: z.strictObject({
+		enabled: z.boolean(),
+		/** Minute of the day the silence starts and ends, in `tz`. Equal values mean no silence. */
+		from: MinuteOfDaySchema,
+		to: MinuteOfDaySchema,
+		tz: TimeZoneSchema,
+		/** The urgent categories that still ring during the silence: none by default. */
+		pass: CategoriesSchema
+	})
+});
+[...NOTIFY_CATEGORIES];
+/** The two briefings: the morning one (what waits) and the evening one (the day, then the calm decisions). */
+const BRIEFING_PARTS = ["morning", "evening"];
+/** The request shape (without the identifier, the version and the product, which the file reading adds). */
+const BriefingRequestFields = {
+	op: z.literal("briefing"),
+	/** Absent: the morning briefing. */
+	part: z.enum(BRIEFING_PARTS).optional()
+};
+const Count$2 = z.int().min(0).max(Number.MAX_SAFE_INTEGER);
+/** What the creator can do with a point from a phone: every decision, none to approve, or none at all. */
+const BRIEFING_ANSWERING = [
+	"full",
+	"no_approval",
+	"elsewhere"
+];
+const BriefingOptionSchema = z.strictObject({
+	id: z.string().min(1).max(64),
+	label: z.string().min(1).max(100),
+	recommended: z.boolean()
+});
+/**
+* What the listening version of a point is made from: the fields its agent already wrote when it
+* opened the point (the card's effect, its first risk and its reason, a deliverable's short
+* version), as plain text, or the start of the summary when no card was written. The device turns
+* them into sentences of its own catalog; the machine never writes a sentence, and nothing is
+* asked of a model. Every field is untrusted text written by an agent.
+*/
+const BriefingListenSchema = z.strictObject({
+	/** What the point changes for the people who use the product (the card's `effect`). */
+	effect: z.string().min(1).max(300).optional(),
+	/** The start of the summary: only when the agent wrote no card. */
+	summary: z.string().min(1).max(600).optional(),
+	/** The first risk of the card. */
+	risk: z.string().min(1).max(200).optional(),
+	/** Why the agent proposes this, and the alternative it set aside. */
+	reason: z.string().min(1).max(200).optional(),
+	rejected: z.string().min(1).max(200).optional(),
+	/** A deliverable's short version, written by its agent for about fifteen seconds of reading. */
+	short: z.string().min(1).max(600).optional()
+});
+const BriefingItemSchema = z.strictObject({
+	/** The checkpoint's identifier: the device finds the point on its own board with it. */
+	id: z.string().min(1).max(64),
+	type: z.string().min(1).max(32),
+	risk: z.enum([
+		"low",
+		"medium",
+		"high"
+	]),
+	/** True when the point holds something back or sits at a high risk (the rule of the notifications). */
+	urgent: z.boolean(),
+	/** True when the point cannot be taken back once decided. */
+	irreversible: z.boolean(),
+	answering: z.enum(BRIEFING_ANSWERING),
+	/** The agent that opened the point, when one did. */
+	agent: z.string().min(1).max(64).optional(),
+	title: z.string().min(1).max(120),
+	story: z.string().min(1).max(32).optional(),
+	options: z.array(BriefingOptionSchema).max(6),
+	/** The fields the listening version is made from; absent when the point has no text to read. */
+	listen: BriefingListenSchema.optional(),
+	/** Set on a story's merge point: the story and the branch it lands on. */
+	merge: z.strictObject({
+		story: z.string().min(1).max(32),
+		base: z.string().min(1).max(100)
+	}).optional()
+});
+/**
+* The day of a product, in the evening briefing: what was delivered since midnight on the machine's
+* clock, how many points still wait at a high risk or holding something back (they are counted,
+* never listed: they are not for the evening), and what the day cost when the bridge could tell.
+*/
+const BriefingDaySchema = z.strictObject({
+	/** Stories merged today. */
+	merged: Count$2,
+	/** Publications the creator validated today. */
+	published: Count$2,
+	/** Decisions the creator made today. */
+	decided: Count$2,
+	/** Points that wait and are urgent: not in `items`. */
+	urgent: Count$2,
+	/** What the measured sessions of the day cost; absent when the costs cannot be read. */
+	cost: z.strictObject({
+		/** Dollars of the models the table prices; absent when no model of the day has a price. */
+		usd: z.number().min(0).max(1e8).optional(),
+		/** `real`, `partial` or `unknown`: a device shows another value as `unknown`. */
+		nature: z.string().min(1).max(16),
+		tokens: Count$2
+	}).optional()
+});
+const BriefingDataSchema = z.strictObject({
+	op: z.literal("briefing"),
+	/** Which briefing this is; absent in a morning briefing. */
+	part: z.enum(BRIEFING_PARTS).optional(),
+	/** The day of the product; present in an evening briefing only. */
+	day: BriefingDaySchema.optional(),
+	/** Milliseconds since the epoch, on the machine's clock. */
+	composed_at: Count$2,
+	/** What moved in the last 24 hours (in the evening briefing, since midnight). */
+	progress: z.strictObject({
+		merged: Count$2,
+		decided: Count$2
+	}),
+	/** How many points wait for the creator (held answers excluded), whatever `items` lists. */
+	waiting: Count$2,
+	items: z.array(BriefingItemSchema).max(12)
+});
+//#endregion
+//#region ../../packages/protocol/dist/budget.js
+/**
+* Budgets: each story's ceiling comes from the journal (the last sprint approved that
+* holds it, or the creator's answer to a budget checkpoint); its cost from the agents' declared
+* costs (`cost.reported`, encrypted). When a declared cost reaches the alert ratio, or goes over
+* the ceiling, `core` writes `budget.threshold_reached` (no amount of cost in it), right after
+* that cost in the same write. Over the ceiling, with `on_exceed: block`, it opens a budget
+* checkpoint in between, and the story's write tools answer `BUDGET_EXCEEDED` until the creator
+* answers it.
+*/
+/** Event types of budgets, each at version 1. */
+const BUDGET_EVENT_TYPES = { thresholdReached: "budget.threshold_reached" };
+/** The thresholds a story's cost may reach: the alert ratio, then the ceiling itself. */
+const BUDGET_LEVELS = ["alert", "exceeded"];
+/** The largest ceiling, in US dollars (raising a ceiling stops there). */
+const MAX_BUDGET_USD = 1e9;
+/** The prefix of a budget checkpoint's title, before the story. */
+const BUDGET_TITLE_PREFIX = "Budget exceeded: ";
+/**
+* The source of a ceiling: the sprint (`S-…`) whose approval set it, or the budget checkpoint
+* (`G-…`) whose answer did. A threshold counts only for the ceiling it names.
+*/
+const CeilingIdSchema = z.string().regex(/^[SG]-[0-9A-HJKMNP-TV-Z]{10}$/, { message: "expected the id of a sprint (S-…) or of a checkpoint (G-…)" });
+/**
+* `payload` of `budget.threshold_reached`: the level reached, the ceiling it was measured against
+* (its amount and its source, never the cost), the settings in force, and the budget checkpoint
+* opened just before it in the same write (`exceeded` under `block` only; absent when one is
+* already open).
+*/
+const BudgetThresholdReachedPayloadSchema = z.strictObject({
+	level: z.enum(BUDGET_LEVELS),
+	budget_usd: z.number().finite().min(0).max(MAX_BUDGET_USD),
+	ceiling: CeilingIdSchema,
+	alert_ratio: z.number().finite().min(MIN_ALERT_RATIO).max(1),
+	on_exceed: z.enum(BUDGET_EXCEED_MODES),
+	checkpoint: CheckpointIdSchema.optional()
+}).superRefine((value, context) => {
+	if (value.checkpoint !== void 0 && (value.level !== "exceeded" || value.on_exceed !== "block")) context.addIssue({
+		code: "custom",
+		path: ["checkpoint"],
+		message: "a checkpoint goes only with an exceeded level under block"
+	});
+});
+//#endregion
+//#region ../../packages/protocol/dist/chain.js
+/** The event the bridge writes when it takes an instruction of the creator for an agent. */
+const CHAIN_EVENT_TYPES = { instructionGiven: "agent.instruction_given" };
+/** The longest instruction, in characters, and how many wait for an agent that is not working. */
+const CHAIN_INSTRUCTION_MAX_CHARS = 4e3;
+z.strictObject({
+	budget_usd: z.number().finite().positive().max(MAX_BUDGET_USD).optional(),
+	max_steps: z.number().int().min(1).max(100).optional()
+});
+const AgentTargetSchema = AgentIdSchema.max(64);
+z.strictObject({
+	agent: AgentTargetSchema.optional(),
+	when: z.enum(["now", "after_step"]).optional(),
+	/**
+	* The creator takes the hand on the agent. The agent is stopped cleanly at once (never after
+	* its step), its session is kept, and the team stays in the creator's hands until they take it
+	* up again. `chat`: the creator talks to the agent from their device, one message at a time
+	* (`chain.say`); `terminal`: they reopen the session in their own terminal on the machine.
+	*/
+	hand: z.enum(["chat", "terminal"]).optional()
+}).refine((value) => value.hand === void 0 || value.when !== "after_step", { message: "the creator takes the session over at once, not after the step" });
+z.strictObject({
+	agent: AgentTargetSchema.optional(),
+	close_session: z.boolean().optional()
+});
+z.strictObject({
+	text: z.string().min(1).max(CHAIN_INSTRUCTION_MAX_CHARS).refine((value) => value.trim().length > 0, { message: "the message is empty" }),
+	close_session: z.boolean().optional()
+});
+z.strictObject({
+	text: z.string().min(1).max(CHAIN_INSTRUCTION_MAX_CHARS).refine((value) => value.trim().length > 0, { message: "the message is empty" }),
+	input: z.enum(["text", "voice"]).optional()
+});
+z.strictObject({ agent: AgentTargetSchema.optional() });
+z.strictObject({
+	agent: AgentTargetSchema,
+	text: z.string().min(1).max(CHAIN_INSTRUCTION_MAX_CHARS).refine((value) => value.trim().length > 0, { message: "the instruction is empty" })
+});
+/** `payload` of `agent.instruction_given`: the creator's instruction, kept encrypted in the journal. */
+const InstructionGivenPayloadSchema = z.strictObject({
+	/** Who the creator spoke to (an agent, or Noah). */
+	to: AgentTargetSchema,
+	/** The agent the instruction goes to when Noah routed it. */
+	routed_to: AgentTargetSchema.optional(),
+	text: z.string().min(1).max(CHAIN_INSTRUCTION_MAX_CHARS),
+	/** `now`: the agent that works is redirected; `queued`: the agent gets it when it next starts. */
+	delivery: z.enum([
+		"now",
+		"queued",
+		"chat"
+	])
+});
+//#endregion
+//#region ../../packages/protocol/dist/checkpoint-closed.js
+/**
+* A point closed by the engine itself: when what a checkpoint asks about is already
+* settled, nobody has to answer it. The engine writes `checkpoint.closed` with the reason, and the
+* projection checks the reason against the journal (a point that is still waiting for something is
+* never closed). The creator is never shown a point whose object is settled.
+*/
+/** Event type of the closing of a checkpoint by the engine, at version 1. */
+const CHECKPOINT_CLOSED_EVENT_TYPES = { closed: "checkpoint.closed" };
+/** `payload` of `checkpoint.closed`: the checkpoint, why, and the newer one for `replaced`. */
+const CheckpointClosedPayloadSchema = z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	reason: z.enum([
+		"story_merged",
+		"review_redone",
+		"replaced",
+		"step_skipped",
+		"block_lifted",
+		"worktree_gone",
+		"lapsed"
+	]),
+	/** The checkpoint that replaces it: with `replaced`, and only with it. */
+	ref: CheckpointIdSchema.optional()
+}).refine((payload) => payload.reason === "replaced" === (payload.ref !== void 0), {
+	message: "a ref goes with replaced, and only with it",
+	path: ["ref"]
+});
+//#endregion
+//#region ../../packages/protocol/dist/checkpoint-decided.js
+/**
+* A point decided by the agent responsible for it. The creator keeps for
+* themselves the points they chose (`validation.points` of `method.yaml`); any other point is
+* decided by an agent, which says why. The decision is written as the agent (`actor.kind: agent`,
+* signed by the machine key), never as the creator: its source and its assurance are `agent`, so
+* the history, the morning summary and every surface always tell it apart from an answer of the
+* creator, and the creator can reopen it at any time.
+*/
+/** Event type of a point decided by an agent, at version 1. */
+const CHECKPOINT_DECIDED_EVENT_TYPES = { decided: "checkpoint.decided" };
+/**
+* What `decide_checkpoint` may be given: a decision, or `escalate`, the agent handing the point back
+* to the creator with its reason when it cannot or should not decide it (a merge the forge refuses
+* and nobody can fix, a point it finds beyond its remit). The point then waits for the creator.
+*/
+const DECIDE_CHOICES = [...CHAT_DECISIONS, "escalate"];
+const ShortIdSchema$1 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, { message: "expected 1 to 32 letters, digits, dots, hyphens or underscores" });
+const ReasonSchema$1 = z.string().trim().min(1).max(1e3);
+function checkOption(value, context) {
+	if (value.decision === "option_chosen" !== (value.option !== void 0)) context.addIssue({
+		code: "custom",
+		path: ["option"],
+		message: "an option goes with option_chosen, and only with it"
+	});
+}
+/**
+* Input of `decide_checkpoint`: the agent that decides, the point, its decision and the reason.
+* `option` goes with `option_chosen` only.
+*/
+const DecideCheckpointInputSchema = z.strictObject({
+	agent: AgentIdSchema.max(64),
+	checkpoint: z.string().trim().toUpperCase().pipe(CheckpointIdSchema),
+	decision: z.enum(DECIDE_CHOICES),
+	option: ShortIdSchema$1.optional(),
+	reason: ReasonSchema$1
+}).superRefine(checkOption);
+/** `payload` of `checkpoint.decided`: the point, the decision and the agent's reason. */
+const CheckpointDecidedPayloadSchema = z.strictObject({
+	checkpoint: CheckpointIdSchema,
+	decision: z.enum(DECIDE_CHOICES),
+	option: ShortIdSchema$1.optional(),
+	reason: ReasonSchema$1
+}).superRefine(checkOption);
+//#endregion
+//#region ../../packages/protocol/dist/ci.js
+/**
 * The CI of a story: `core` reads the checks of the story's pull request through the
 * forge's command-line tool (`gh`, `glab`), then writes `story.ci_reported`. A failed CI sends the
 * story back to its agent; a merge checkpoint waits for a green CI and a done review. When the CI
@@ -5357,6 +6204,364 @@ const CheckCiInputSchema = z.strictObject({
 	forge: z.enum(CI_FORGES).optional()
 });
 //#endregion
+//#region ../../packages/protocol/dist/forge-link.js
+/**
+* Linking a code platform (GitHub, GitLab) to a machine. The creator's device asks, with a signed
+* order, for the machine to be authorised at the platform; the machine does it itself, keeps the
+* token in its own system keychain and says what became of it in its report. The token is in none
+* of these shapes: a device only ever learns the state of a link (who, how far, until when) and,
+* while an authorisation is under way, the short code and the public address to enter it at.
+*/
+/** The platforms a machine can be linked to. */
+const FORGE_PROVIDERS = ["github", "gitlab"];
+const ForgeHostSchema = z.string().max(50).regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*(?::[1-9][0-9]{0,4})?$/).refine((host) => {
+	const port = host.split(":")[1];
+	return port === void 0 || Number(port) <= 65535;
+});
+z.strictObject({
+	provider: z.enum(FORGE_PROVIDERS),
+	host: ForgeHostSchema.optional()
+});
+const ForgeLinkStatusSchema = z.strictObject({
+	provider: z.enum(FORGE_PROVIDERS),
+	host: ForgeHostSchema,
+	state: z.enum([
+		"pending",
+		"linked",
+		"relink",
+		"failed"
+	]),
+	/** How the token was obtained: the platform's device flow, or given on the machine. */
+	method: z.enum(["device", "token"]).optional(),
+	/** The account the token belongs to (the platform's login). */
+	account: z.string().min(1).max(100).optional(),
+	access: z.enum([
+		"read",
+		"write",
+		"unknown"
+	]).optional(),
+	/** The scopes or permissions the platform reported, as it names them. */
+	scopes: z.array(z.string().min(1).max(60)).max(12).optional(),
+	repos: z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("all") }), z.strictObject({
+		kind: z.literal("listed"),
+		names: z.array(z.string().min(1).max(140)).max(30),
+		more: z.boolean()
+	})]).optional(),
+	linked_at: z.iso.datetime().optional(),
+	/** When the token stops working; absent when the platform did not say. */
+	expires_at: z.iso.datetime().optional(),
+	pending: z.strictObject({
+		user_code: z.string().min(1).max(32),
+		/** The public address to enter the code at. */
+		verification_uri: z.string().max(300),
+		expires_at: z.iso.datetime()
+	}).optional(),
+	failure: z.enum([
+		"expired",
+		"denied",
+		"unreachable",
+		"rejected",
+		"not_saved"
+	]).optional()
+});
+const CODE_PATCH_MAX_CHARS = 4e4;
+const CODE_TEXT_MAX_CHARS = 2e3;
+/** The number of a pull request (GitHub) or merge request (GitLab) in its repository. */
+const CodePullNumberSchema = z.int().min(1).max(1e9);
+const CODE_PULL_STATES = [
+	"open",
+	"draft",
+	"merged",
+	"closed"
+];
+/** Where the checks of a pull request stand; `unknown` when the bridge did not read them. */
+const CODE_CHECKS_STATES = [
+	"passed",
+	"failed",
+	"running",
+	"none",
+	"unknown"
+];
+/** Where the review of a pull request stands; `unknown` when the bridge did not read it. */
+const CODE_REVIEW_STATES = [
+	"approved",
+	"changes_requested",
+	"pending",
+	"none",
+	"unknown"
+];
+/** The repository the pull requests are read from, as the machine knows it. */
+const CodeRepositorySchema = z.strictObject({
+	provider: z.enum(FORGE_PROVIDERS),
+	host: ForgeHostSchema,
+	/** `owner/name` (GitLab: the group path, possibly nested). */
+	path: z.string().min(3).max(200)
+});
+const CodeChecksSummarySchema = z.strictObject({
+	state: z.enum(CODE_CHECKS_STATES),
+	passed: z.int().min(0).max(1e4),
+	failed: z.int().min(0).max(1e4),
+	total: z.int().min(0).max(1e4)
+});
+const CodePullSchema = z.strictObject({
+	number: CodePullNumberSchema,
+	title: z.string().max(200),
+	state: z.enum(CODE_PULL_STATES),
+	/** The platform's login of the author. */
+	author: z.string().min(1).max(100).optional(),
+	/** The branch the work is on, and the branch it aims at. */
+	branch: z.string().max(200),
+	base: z.string().max(200),
+	/** The address of the pull request at the platform, built by the bridge. */
+	url: z.string().max(400),
+	created_at: z.iso.datetime(),
+	updated_at: z.iso.datetime(),
+	checks: CodeChecksSummarySchema,
+	review: z.enum(CODE_REVIEW_STATES),
+	additions: z.int().min(0).optional(),
+	deletions: z.int().min(0).optional(),
+	files: z.int().min(0).optional()
+});
+const CodeCheckSchema = z.strictObject({
+	name: z.string().min(1).max(120),
+	state: z.enum([
+		"passed",
+		"failed",
+		"running",
+		"queued",
+		"skipped"
+	]),
+	/** How long the step took, in seconds, when the platform says. */
+	seconds: z.int().min(0).max(1e6).optional()
+});
+const CodeReviewSchema = z.strictObject({
+	author: z.string().min(1).max(100).optional(),
+	verdict: z.enum([
+		"approved",
+		"changes_requested",
+		"commented",
+		"dismissed"
+	]),
+	body: z.string().max(CODE_TEXT_MAX_CHARS).optional(),
+	at: z.iso.datetime().optional()
+});
+/** A remark anchored to a line of a file of the pull request. */
+const CodeRemarkSchema = z.strictObject({
+	id: z.string().min(1).max(40),
+	author: z.string().min(1).max(100).optional(),
+	path: z.string().min(1).max(1024),
+	/** The line of the file: after the change (`new`) or before it (`old`, a removed line). */
+	line: z.int().min(1).max(1e7),
+	side: z.enum(["new", "old"]),
+	body: z.string().max(CODE_TEXT_MAX_CHARS),
+	at: z.iso.datetime().optional()
+});
+/**
+* One file of a difference. `patch` is the platform's unified difference without its header (it
+* starts at the first `@@` line), each line that looked like a secret replaced by the fixed
+* notice; absent for a binary or a very large file.
+*/
+const CodeDiffFileSchema = z.strictObject({
+	path: z.string().min(1).max(1024),
+	from: z.string().min(1).max(1024).optional(),
+	status: z.enum([
+		"added",
+		"modified",
+		"deleted",
+		"renamed"
+	]),
+	additions: z.int().min(0),
+	deletions: z.int().min(0),
+	patch: z.string().max(CODE_PATCH_MAX_CHARS).optional(),
+	/** The patch is cut at the longest the bridge sends. */
+	truncated: z.literal(true).optional(),
+	/** The platform shows no text for this file (binary, or too large for it). */
+	unavailable: z.literal(true).optional(),
+	/** The file is a secret's by its name: its difference is never sent. */
+	protected: z.literal(true).optional()
+});
+/** The editors a link can open. The scheme of each is fixed on the device; nothing is run. */
+const CODE_EDITORS = [
+	"vscode",
+	"cursor",
+	"windsurf",
+	"vscodium",
+	"zed",
+	"idea",
+	"webstorm",
+	"pycharm"
+];
+const CODE_PLATFORMS = [
+	"windows",
+	"macos",
+	"linux",
+	"other"
+];
+/** The working copy an editor is opened on: the product's own folder, or a story's branch. */
+const CodeEditorRefSchema = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("worktree") }), z.strictObject({
+	kind: z.literal("workspace"),
+	branch: z.string().min(1).max(200)
+})]);
+/** The request shapes (without the identifier, the version and the product, which the file reading adds). */
+const CodePullsRequestFields = { op: z.literal("pulls") };
+const CodePullRequestFields = {
+	op: z.literal("pull"),
+	number: CodePullNumberSchema
+};
+const CodeDiffRequestFields = {
+	op: z.literal("pull_diff"),
+	number: CodePullNumberSchema
+};
+const CodeEditorRequestFields = {
+	op: z.literal("editor"),
+	ref: CodeEditorRefSchema
+};
+/** What an answer carries. */
+const CodePullsDataSchema = z.strictObject({
+	op: z.literal("pulls"),
+	repository: CodeRepositorySchema,
+	pulls: z.array(CodePullSchema).max(30),
+	/** True when the platform has more than the bridge lists. */
+	truncated: z.boolean()
+});
+const CodePullDataSchema = z.strictObject({
+	op: z.literal("pull"),
+	repository: CodeRepositorySchema,
+	pull: CodePullSchema,
+	checks: z.array(CodeCheckSchema).max(60),
+	reviews: z.array(CodeReviewSchema).max(30),
+	remarks: z.array(CodeRemarkSchema).max(100)
+});
+const CodeDiffDataSchema = z.strictObject({
+	op: z.literal("pull_diff"),
+	repository: CodeRepositorySchema,
+	number: CodePullNumberSchema,
+	files: z.array(CodeDiffFileSchema).max(100),
+	/** True when the pull request changes more files than the bridge sends. */
+	truncated: z.boolean()
+});
+const CodeEditorDataSchema = z.strictObject({
+	op: z.literal("editor"),
+	/** The folder of the working copy on the machine. */
+	folder: z.string().min(1).max(1024),
+	/** The branch checked out there, when it is on one. */
+	branch: z.string().min(1).max(200).optional(),
+	/** The system of the machine, so that a device of another system knows the link is not for it. */
+	platform: z.enum(CODE_PLATFORMS),
+	/** The editors found on the machine, best known first. */
+	detected: z.array(z.enum(CODE_EDITORS)).max(CODE_EDITORS.length)
+});
+/** The stable codes of a refusal that only the code reading gives. */
+const CODE_ERROR_CODES = [
+	"NOT_LINKED",
+	"NO_REMOTE",
+	"FORGE_REFUSED",
+	"FORGE_UNREACHABLE",
+	"FORGE_BUSY"
+];
+/** The request shape (without the identifier, the version and the product, which the file reading adds). */
+const CostsRequestFields = {
+	op: z.literal("costs"),
+	period: z.enum([
+		"today",
+		"week",
+		"sprint",
+		"month",
+		"all"
+	]).optional()
+};
+const Count$1 = z.int().min(0).max(Number.MAX_SAFE_INTEGER);
+/** What a set of measured parts consumed, and what it costs at the table's prices. */
+const CostFiguresSchema = z.strictObject({
+	/** The dollars of the models the table prices; absent when `nature` is `unknown`. */
+	usd: z.number().min(0).max(1e8).optional(),
+	nature: z.string().min(1).max(16),
+	tokens_in: Count$1,
+	tokens_out: Count$1,
+	cache_read: Count$1,
+	cache_write: Count$1,
+	/** Working time, in milliseconds. */
+	active_ms: Count$1,
+	/** The models that have no price in the table (their tokens count, their dollars do not). */
+	unpriced: z.array(z.string().min(1).max(100)).max(8)
+});
+const CostWorkSchema = z.strictObject({
+	kind: z.string().min(1).max(24),
+	/** The file's name, the checkpoint, the story, ... that the work is about. */
+	key: z.string().min(1).max(128),
+	label: z.string().max(200).optional(),
+	/** The agent that did it; `noah` for the creator's conversation with Noah. */
+	agent: z.string().min(1).max(64),
+	story: z.string().regex(/^[1-9]\d{0,5}-[1-9]\d{0,5}$/).optional(),
+	figures: CostFiguresSchema
+});
+const CostPhaseSchema = z.strictObject({
+	/** The phase of the method; absent for what ran when no phase was current. */
+	phase: z.string().min(1).max(32).optional(),
+	figures: CostFiguresSchema,
+	works: z.array(CostWorkSchema).max(60),
+	/** True when the phase holds more works than listed (the figures count them all). */
+	truncated: z.boolean()
+});
+const CostAgentSchema = z.strictObject({
+	agent: z.string().min(1).max(64),
+	figures: CostFiguresSchema
+});
+const CostStorySchema = z.strictObject({
+	story: z.string().regex(/^[1-9]\d{0,5}-[1-9]\d{0,5}$/),
+	/** The sprint that carries it, when one does. */
+	sprint: z.string().min(1).max(64).optional(),
+	figures: CostFiguresSchema
+});
+const CostSprintSchema = z.strictObject({
+	id: z.string().min(1).max(64),
+	goal: z.string().max(200),
+	/** Where the sprint stands (`in_force`, `superseded`, ...); a device shows an unknown one in neutral words. */
+	status: z.string().min(1).max(24),
+	stories: Count$1,
+	/** The budget the sprint was planned with, in dollars. */
+	budget_usd: z.number().min(0).max(1e8),
+	figures: CostFiguresSchema
+});
+/** What the agents declared on their own, apart from the measure. */
+const CostDeclaredAgentSchema = z.strictObject({
+	agent: z.string().min(1).max(64),
+	/** Dollars declared as real, and as estimated. */
+	usd: z.number().min(0).max(1e8),
+	usd_estimated: z.number().min(0).max(1e8),
+	tokens_in: Count$1,
+	tokens_out: Count$1
+});
+const CostDeclaredSchema = z.strictObject({
+	usd: z.number().min(0).max(1e8),
+	usd_estimated: z.number().min(0).max(1e8),
+	tokens_in: Count$1,
+	tokens_out: Count$1,
+	agents: z.array(CostDeclaredAgentSchema).max(60)
+});
+const CostsDataSchema = z.strictObject({
+	op: z.literal("costs"),
+	period: z.string().min(1).max(16),
+	/** The price table the dollars were computed with. */
+	table: z.strictObject({
+		version: z.string().min(1).max(32),
+		as_of: z.string().min(1).max(32)
+	}),
+	/** False when no session was measured in the period: no figure, never a zero. */
+	measured: z.boolean(),
+	/** How many measured sessions the figures come from. */
+	sessions: Count$1,
+	total: CostFiguresSchema,
+	phases: z.array(CostPhaseSchema).max(12),
+	agents: z.array(CostAgentSchema).max(60),
+	stories: z.array(CostStorySchema).max(400),
+	sprints: z.array(CostSprintSchema).max(60),
+	/** Absent when no agent declared a cost (or the period is not `all`: declarations carry no date). */
+	declared: CostDeclaredSchema.optional(),
+	/** True when a list was cut at its limit (the totals count everything). */
+	truncated: z.boolean()
+});
+//#endregion
 //#region ../../packages/protocol/dist/install.js
 /**
 * The installations the approved architecture plans. The architecture document
@@ -6010,216 +7215,303 @@ const AgentDelegatedPayloadSchema = z.strictObject({
 	brief: BriefSchema
 });
 //#endregion
-//#region ../../packages/protocol/dist/device-trust.js
+//#region ../../packages/protocol/dist/trace.js
 /**
-* The devices of trust in the journal. A product's
-* registry of trusted devices is its journal: `device.paired` says "this key is trusted",
-* `device.revoked` takes it back, `device.confirmed` ends the provisional state of a device whose
-* handover is complete, `device.root_certified` records that the first phone recognised the root,
-* and `trust.dismissed` clears a `SECURITY_ROOT_CHANGED` alert. The chain of authorizations must
-* lead to the root the bridge pinned locally, outside the repository: never to an event's ULID.
-*
-* Generic on purpose: schemas and rules only, no transport, no account, no offer.
+* Traceability and deviations. Each requirement of the PRD (`EF-n`, `ENF-n`) is linked,
+* at read time, to the stories that cite it, their pull requests, the tests that cite it and the
+* deviations recorded on it: nothing of that link is ever written in a document. A deviation is a
+* signed event of the journal: an agent (the QA reviewer) found the delivered work drifting from
+* requirements a started story cites. Its id, like an item of deferred work's, is `V-` then the
+* last 10 characters of the ULID of its event, never written in the `payload`, never reused.
 */
-/** Event types of the devices of trust, each at version 1. */
-const DEVICE_TRUST_EVENT_TYPES = {
-	paired: "device.paired",
-	revoked: "device.revoked",
-	rootCertified: "device.root_certified",
-	confirmed: "device.confirmed",
-	dismissed: "trust.dismissed"
+/** Event types of the deviations, each at version 1. */
+const DEVIATION_EVENT_TYPES = {
+	reported: "deviation.reported",
+	resolved: "deviation.resolved"
 };
-/**
-* The types the engine writes as a system actor (the bridge, or a creator's terminal for the
-* first ones): refused in any write by an agent. `trust.dismissed` is the creator's (signed by
-* the creator's key).
-*/
-const DEVICE_TRUST_SYSTEM_EVENT_TYPES = /* @__PURE__ */ new Set([
-	DEVICE_TRUST_EVENT_TYPES.paired,
-	DEVICE_TRUST_EVENT_TYPES.revoked,
-	DEVICE_TRUST_EVENT_TYPES.rootCertified,
-	DEVICE_TRUST_EVENT_TYPES.confirmed
-]);
-new Set(Object.values(DEVICE_TRUST_EVENT_TYPES));
-/** The kinds of device a `device.paired` registers (the creator's key has its own events). */
-const PAIRED_DEVICE_KINDS = [
-	"machine",
-	"phone",
-	"browser"
+/** Where a requirement stands: to do, in development, in review, delivered, or deviating. */
+const REQUIREMENT_STATUSES = [
+	"todo",
+	"in_development",
+	"in_review",
+	"delivered",
+	"deviation"
 ];
-/** `machine:`, `human:`, `phone:` or `browser:` then 16 base64url characters. */
-const DEVICE_ID_PATTERN = /^(machine|human|phone|browser):[A-Za-z0-9_-]{16}$/;
-/** The identifier of a device `device.paired` registers. */
-const PAIRED_DEVICE_ID_PATTERN = /^(machine|phone|browser):[A-Za-z0-9_-]{16}$/;
-/** The identifier of a bridge. */
-const BRIDGE_ID_PATTERN = /^machine:[A-Za-z0-9_-]{16}$/;
-/** The kind of identifier (`machine`, `human`, `phone`, `browser`), or undefined when malformed. */
-function deviceKindOf(device) {
-	if (!DEVICE_ID_PATTERN.test(device)) return void 0;
-	return device.slice(0, device.indexOf(":"));
-}
-/** The algorithms of the linked devices (the `webauthn-*` ones serve the terminal's key only). */
-const DEVICE_SIG_ALG = "ed25519";
-const DEVICE_ENC_ALG = "x25519";
-/** 32 bytes in base64url: 43 characters, the last one carrying 4 bits only. */
-const PUBLIC_KEY_32 = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
-/** 16 random bytes in base64url: 22 characters, the last one carrying 2 bits only. */
-const RANDOM_16 = /^[A-Za-z0-9_-]{21}[AQgw]$/;
-/** `sha256:` then the 32-byte digest in base64url (an event's hash). */
-const TRUST_EVENT_HASH_PATTERN = /^sha256:[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
-const publicKey32 = z.string().regex(PUBLIC_KEY_32).refine(isCanonicalBase64url);
-const utcDatetime = z.iso.datetime();
-/** A public key of a device with its algorithm: `{ alg, key }`. */
-const DeviceSigKeySchema = z.strictObject({
-	alg: z.literal(DEVICE_SIG_ALG),
-	key: publicKey32
-});
-const DeviceEncKeySchema = z.strictObject({
-	alg: z.literal(DEVICE_ENC_ALG),
-	key: publicKey32
-});
-/**
-* Every signed structure of trust carries its label `t` (type and version), and a key signs the
-* types it knows only: an authorization is never taken for an order, nor a relay's challenge for
-* an authorization. The domain separation stops a signature made for one purpose from
-* serving another.
-*/
-const TRUST_SIGNATURE_TAGS = {
-	devicePaired: "device.paired.auth/v1",
-	deviceRevoked: "device.revoked.auth/v1",
-	pairOffer: "pair.offer/v1",
-	rootCertified: "device.root_certified.auth/v1",
-	message: "msg.inner/v1",
-	linkWelcome: "link.welcome/v1"
-};
-/** True for a label this engine knows. */
-function isTrustSignatureTag(tag) {
-	return Object.values(TRUST_SIGNATURE_TAGS).includes(tag);
+/** The requirements traced: the functional and non-functional ones of the PRD. */
+const TRACED_REQUIREMENT_PATTERN = /^(?:EF|ENF)-[1-9]\d*$/;
+/** A traced requirement as typed (`ef-18`, with spaces): trimmed, in upper case, then checked. */
+const TracedRequirementInputSchema = z.string().trim().toUpperCase().pipe(z.string().regex(TRACED_REQUIREMENT_PATTERN, { message: "expected EF-n or ENF-n, for example EF-18" }));
+/** `V-` then the last 10 characters of the ULID of the event that reported the deviation. */
+const DeviationIdSchema = z.string().regex(/^V-[0-9A-HJKMNP-TV-Z]{10}$/, { message: "expected V- then 10 characters, for example V-7M2K9QX4TB" });
+/** An id as typed (`v-7m2k9qx4tb`, with spaces): trimmed and in upper case, then checked. */
+const DeviationIdInputSchema = z.string().trim().toUpperCase().pipe(DeviationIdSchema);
+/** The id of the deviation reported by the event `eventId`: stable, never renumbered. */
+function deviationIdOf(eventId) {
+	return `V-${eventId.slice(-10)}`;
 }
+const NO_CONTROL$2 = { message: "expected no control character" };
+const SummarySchema = z.string().trim().min(1).max(200).refine((summary) => !/[\r\n]/.test(summary), { message: "expected a single line" }).refine((summary) => !hasControlCharacter(summary, false), NO_CONTROL$2);
+const DetailSchema = z.string().trim().min(1).max(2e3).refine((detail) => !hasControlCharacter(detail, true), NO_CONTROL$2);
+const ReasonSchema = z.string().trim().min(1).max(1e3).refine((reason) => !hasControlCharacter(reason, true), NO_CONTROL$2);
+const RequirementIdSchema = z.string().regex(REQUIREMENT_ID_PATTERN, { message: "expected a requirement id (EF-n, ENF-n, PU-n, MS-n or AD-n)" });
+const requirementsOf = (id) => z.array(id).min(1).max(20).refine((ids) => new Set(ids).size === ids.length, { message: "requirements must differ" });
 /**
-* The order of a trusted device that offered a pairing (`pair.offer`): one rendezvous
-* `x`, valid until `expires_at`, for one device of `kind`. The bridge writes `device.paired` on
-* its authority, once.
-*/
-const PairOfferSchema = z.strictObject({
-	x: z.string().regex(RANDOM_16).refine(isCanonicalBase64url),
-	expires_at: utcDatetime
-});
-/**
-* The proof that the creator wanted this: the signature, by a device already trusted (or by the
-* root, from the command run on the root machine), of the record of the event (`order` absent) or
-* of the signed order `pair.offer` (`order` present).
+* `payload` of `deviation.reported`. The story is the envelope's (required); `pr` is the number of
+* the story's pull request when the deviation was reported, set by the engine from the journal.
 */
-const AuthorizationSchema = z.strictObject({
-	signer: z.string().regex(DEVICE_ID_PATTERN),
-	alg: z.literal(DEVICE_SIG_ALG),
-	sig: Ed25519SignatureSchema,
-	order: PairOfferSchema.optional()
-});
-/** `payload` of `device.paired` v1. */
-const DevicePairedPayloadSchema = z.strictObject({
-	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
-	kind: z.enum(PAIRED_DEVICE_KINDS),
-	sig: DeviceSigKeySchema,
-	enc: DeviceEncKeySchema,
-	/** The bridge of the perimeter: the authorization holds in the journals this bridge writes. */
-	bridge: z.string().regex(BRIDGE_ID_PATTERN),
-	/** True until the handover is complete (`device.confirmed`): the bridge alone may revoke it. */
-	provisional: z.boolean(),
-	issued_at: utcDatetime,
-	authorization: AuthorizationSchema
-}).refine((payload) => payload.device.startsWith(`${payload.kind}:`), {
-	path: ["kind"],
-	message: "the kind is the prefix of the device"
-});
-/** `payload` of `device.revoked` v1. */
-const DeviceRevokedPayloadSchema = z.strictObject({
-	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
-	/**
-	* For a machine that writes to the journal: the hash of its last event the author knew. The
-	* projection accepts of a revoked machine only the ancestors of this head (and of the heads of
-	* the other revocations of it). Null for a device that writes nothing.
-	*/
-	chain_head: z.string().regex(TRUST_EVENT_HASH_PATTERN).nullable(),
-	issued_at: utcDatetime,
-	author: z.string().regex(DEVICE_ID_PATTERN),
-	authorization: z.strictObject({
-		alg: z.literal(DEVICE_SIG_ALG),
-		sig: Ed25519SignatureSchema
-	})
-}).refine((payload) => payload.chain_head === null || payload.device.startsWith("machine:"), {
-	path: ["chain_head"],
-	message: "only a machine has a chain head"
-});
-/** `payload` of `device.root_certified` v1: the first phone recognises the root. */
-const DeviceRootCertifiedPayloadSchema = z.strictObject({
-	root: z.strictObject({
-		device: z.string().regex(DEVICE_ID_PATTERN),
-		key: publicKey32
-	}),
-	issued_at: utcDatetime,
-	authorization: AuthorizationSchema
-});
-/** `payload` of `device.confirmed` v1: the handover of the device is complete. */
-const DeviceConfirmedPayloadSchema = z.strictObject({
-	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
-	issued_at: utcDatetime
-});
-/** `payload` of `trust.dismissed` v1: the events (their hashes) the creator dismisses. */
-const TrustDismissedPayloadSchema = z.strictObject({
-	events: z.array(z.string().regex(TRUST_EVENT_HASH_PATTERN)).min(1).max(16),
-	issued_at: utcDatetime
+const DeviationReportedPayloadSchema = z.strictObject({
+	requirements: requirementsOf(RequirementIdSchema),
+	summary: SummarySchema,
+	detail: DetailSchema.optional(),
+	pr: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).optional(),
+	/** The commit compared with the requirements. */
+	commit: CommitIdSchema.optional()
 });
-/** The pinned root of a product, kept locally outside the repository (written by `pair`). */
-const RootPinSchema = z.strictObject({
-	device: z.string().regex(/^(machine|human):[A-Za-z0-9_-]{16}$/),
-	public_key: publicKey32
+/** `payload` of `deviation.resolved`: the deviation, and how it was fixed or why it is lifted. */
+const DeviationResolvedPayloadSchema = z.strictObject({
+	deviation: DeviationIdSchema,
+	reason: ReasonSchema
+});
+/** A requirement id as typed: in upper case, then checked. */
+const RequirementInputSchema = z.string().trim().toUpperCase().pipe(RequirementIdSchema);
+/** Input of `report_deviation`: the story brought to its canonical form. */
+const ReportDeviationInputSchema = z.strictObject({
+	agent: AgentIdSchema.max(64),
+	story: StoryIdSchema.overwrite(canonicalStoryId),
+	requirements: requirementsOf(RequirementInputSchema),
+	summary: SummarySchema,
+	detail: DetailSchema.optional(),
+	commit: CommitIdSchema.optional()
+});
+/** Input of `lift_deviation`: the agent that reported it lifts it, with why. */
+const ResolveDeviationInputSchema = z.strictObject({
+	agent: AgentIdSchema.max(64),
+	deviation: DeviationIdInputSchema,
+	reason: ReasonSchema
+});
+/** The reason the creator gives at the terminal (`trace resolve`). */
+const DeviationReasonSchema = ReasonSchema;
+/** Input of `get_trace`: one requirement, or every one when absent. */
+const GetTraceInputSchema = z.strictObject({ requirement: z.string().max(32).optional() });
+const DOCS_TEXT_MAX_CHARS = 2e3;
+/** Where a story stands, as the engine sees it. */
+const DOCS_STORY_STATUSES = [
+	"todo",
+	"in_progress",
+	"in_review",
+	"blocked",
+	"done"
+];
+const StoryRef = z.string().regex(/^[1-9]\d{0,5}-[1-9]\d{0,5}$/);
+const RequirementRef = z.string().regex(TRACED_REQUIREMENT_PATTERN).max(16);
+/** The request shapes (without the identifier, the version and the product, which the file reading adds). */
+const DocsListRequestFields = { op: z.literal("docs") };
+const DocsTraceRequestFields = {
+	op: z.literal("trace"),
+	requirement: RequirementRef
+};
+const DocsRetrosRequestFields = { op: z.literal("retros") };
+/** One document of the product: a file of `docs/` or `epics/` (the stories are told by the breakdown). */
+const DocsDocumentSchema = z.strictObject({
+	/** The path from the product's folder, with `/`. */
+	path: z.string().min(1).max(300),
+	/** The header's kind (`prd`, `architecture`...), or `unknown` when the header is not valid. */
+	kind: z.string().min(1).max(32),
+	id: z.string().min(1).max(64).optional(),
+	title: z.string().min(1).max(200).optional(),
+	/** The agent that owns it, or `creator`. */
+	owner: z.string().min(1).max(64).optional(),
+	standing: z.string().min(1).max(32),
+	/** The requirements it defines (active and retired), when it defines any. */
+	requirements: z.int().min(0).max(1e5).optional(),
+	/** The documents and requirements its header links to. */
+	links: z.array(z.string().min(1).max(64)).max(40).optional()
+});
+const DocsRequirementSchema = z.strictObject({
+	id: RequirementRef,
+	text: z.string().max(400),
+	/** The document that defines it. */
+	path: z.string().min(1).max(300),
+	/** Retired: the id stays reserved, the status below is not meaningful. */
+	retired: z.boolean(),
+	status: z.enum(REQUIREMENT_STATUSES),
+	stories: z.array(StoryRef).max(100),
+	/** The test files that cite it, or null when the tests could not be read. */
+	tests: z.int().min(0).max(1e5).nullable(),
+	pull_requests: z.int().min(0).max(1e5),
+	/** Its open deviations. */
+	deviations: z.int().min(0).max(1e5)
+});
+const DocsDeviationSchema = z.strictObject({
+	id: z.string().regex(/^V-[0-9A-HJKMNP-TV-Z]{10}$/),
+	story: StoryRef,
+	requirements: z.array(z.string().min(1).max(16)).max(20),
+	summary: z.string().max(200),
+	reported_by: z.string().min(1).max(64),
+	reported_at: z.string().max(40)
+});
+const DocsBreakdownStorySchema = z.strictObject({
+	id: StoryRef,
+	title: z.string().min(1).max(200).optional(),
+	status: z.enum(DOCS_STORY_STATUSES),
+	depends_on: z.array(StoryRef).max(40),
+	requirements: z.array(RequirementRef).max(40)
+});
+const DocsEpicSchema = z.strictObject({
+	/** `epic-2`. */
+	id: z.string().regex(/^epic-[1-9]\d{0,5}$/),
+	title: z.string().min(1).max(200).optional(),
+	/** The path of the epic's document, when it has one. */
+	path: z.string().min(1).max(300).optional(),
+	out_of_scope: z.array(RequirementRef).max(200),
+	stories: z.array(DocsBreakdownStorySchema).max(600)
+});
+const DocsCoverageSchema = z.strictObject({
+	/** The active functional and non-functional requirements. */
+	total: z.int().min(0).max(1e5),
+	/** Those a story carries. */
+	covered: z.int().min(0).max(1e5),
+	/** Those an epic leaves aside. */
+	out_of_scope: z.int().min(0).max(1e5),
+	/** The others, by id. */
+	uncovered: z.array(RequirementRef).max(200)
+});
+const DOCS_TESTS_STATES = [
+	"read",
+	"truncated",
+	"unavailable"
+];
+const CountsSchema = z.strictObject({
+	todo: z.int().min(0),
+	in_development: z.int().min(0),
+	in_review: z.int().min(0),
+	delivered: z.int().min(0),
+	deviation: z.int().min(0)
+});
+const DocsListDataSchema = z.strictObject({
+	op: z.literal("docs"),
+	documents: z.array(DocsDocumentSchema).max(200),
+	/** True when the product holds more documents than the bridge lists. */
+	truncated: z.boolean(),
+	requirements: z.array(DocsRequirementSchema).max(800),
+	/** How many active requirements stand at each status. */
+	counts: CountsSchema,
+	/** How the tests were read: all of them, a part, or not at all. */
+	tests: z.enum(DOCS_TESTS_STATES),
+	/** The open deviations. */
+	deviations: z.array(DocsDeviationSchema).max(50),
+	epics: z.array(DocsEpicSchema).max(100),
+	/** Absent while no story exists: nothing is covered or not yet. */
+	coverage: DocsCoverageSchema.optional()
+});
+const DocsTraceDeviationSchema = DocsDeviationSchema.extend({
+	detail: z.string().max(DOCS_TEXT_MAX_CHARS).optional(),
+	status: z.enum(["open", "resolved"]),
+	resolved: z.strictObject({
+		reason: z.string().max(DOCS_TEXT_MAX_CHARS),
+		by: z.string().min(1).max(64),
+		at: z.string().max(40)
+	}).optional()
+});
+const DocsTraceDataSchema = z.strictObject({
+	op: z.literal("trace"),
+	requirement: z.strictObject({
+		id: RequirementRef,
+		text: z.string().max(400),
+		path: z.string().min(1).max(300),
+		line: z.int().min(1).max(1e7),
+		retired: z.boolean(),
+		status: z.enum(REQUIREMENT_STATUSES),
+		stories: z.array(z.strictObject({
+			id: StoryRef,
+			title: z.string().min(1).max(200).optional(),
+			status: z.enum(DOCS_STORY_STATUSES)
+		})).max(100),
+		tests: z.array(z.strictObject({
+			path: z.string().min(1).max(300),
+			/** 0: the file's name cites it. */
+			line: z.int().min(0).max(1e7)
+		})).max(100),
+		pull_requests: z.array(z.strictObject({
+			story: StoryRef,
+			number: z.int().min(1).max(1e9)
+		})).max(100),
+		deviations: z.array(DocsTraceDeviationSchema).max(100)
+	}),
+	tests_state: z.enum(DOCS_TESTS_STATES)
+});
+/** Where a retrospective stands: the creator's answer to its checkpoint decides. */
+const RETRO_STATUSES = [
+	"open",
+	"approved",
+	"changes_requested",
+	"dismissed"
+];
+/**
+* What became of a proposed lesson: still `proposed` (nothing recorded), `active` (recorded and in
+* force), `retired` or `superseded` since, or `not_kept` (its retrospective was not approved).
+*/
+const RETRO_LESSON_STATUSES = [
+	"proposed",
+	"active",
+	"retired",
+	"superseded",
+	"not_kept"
+];
+const LessonText = z.string().max(DOCS_TEXT_MAX_CHARS);
+const LessonRef = z.string().regex(/^L-[0-9A-HJKMNP-TV-Z]{10}-[1-9][0-9]?$/);
+const DocsRetroSchema = z.strictObject({
+	id: z.string().regex(/^R-[0-9A-HJKMNP-TV-Z]{10}$/),
+	scope: z.strictObject({
+		kind: z.enum(["epic", "sprint"]),
+		id: z.string().min(1).max(16)
+	}),
+	at: z.string().max(40),
+	proposed_by: z.string().min(1).max(64),
+	status: z.enum(RETRO_STATUSES),
+	summary: LessonText,
+	lessons: z.array(z.strictObject({
+		id: LessonRef,
+		title: z.string().max(200),
+		text: LessonText,
+		tags: z.array(z.string().min(1).max(32)).max(5),
+		agents: z.array(z.string().min(1).max(64)).max(10),
+		status: z.enum(RETRO_LESSON_STATUSES)
+	})).max(12),
+	retire: z.array(z.strictObject({
+		lesson: LessonRef,
+		reason: LessonText
+	})).max(12),
+	actions: z.array(z.strictObject({
+		id: z.string().min(1).max(32),
+		text: LessonText,
+		owner: z.string().min(1).max(64).optional()
+	})).max(12)
+});
+/** A lesson in force: what the agents read at the start of a task. */
+const DocsMemoryLessonSchema = z.strictObject({
+	id: LessonRef,
+	title: z.string().max(200),
+	text: LessonText,
+	tags: z.array(z.string().min(1).max(32)).max(5),
+	agents: z.array(z.string().min(1).max(64)).max(10),
+	at: z.string().max(40),
+	/** The retrospective it comes from. */
+	retro: z.string().regex(/^R-[0-9A-HJKMNP-TV-Z]{10}$/),
+	/** True when it was also promoted to the common memory of the machine. */
+	promoted: z.boolean()
+});
+const DocsRetrosDataSchema = z.strictObject({
+	op: z.literal("retros"),
+	retrospectives: z.array(DocsRetroSchema).max(40),
+	/** The lessons in force, newest first. */
+	memory: z.array(DocsMemoryLessonSchema).max(120),
+	/**
+	* The retrospectives whose content this machine could not read (the product's key is missing
+	* here): they are counted, never guessed.
+	*/
+	unreadable: z.int().min(0).max(1e5)
 });
-/**
-* What the authorization of a `device.paired` signs: its payload without `authorization`, plus the
-* label. Independent of the product and of `prev`: the bridge writes it in each journal it serves,
-* but cannot make one without the signer.
-*/
-function devicePairedRecord(payload) {
-	return {
-		t: TRUST_SIGNATURE_TAGS.devicePaired,
-		device: payload.device,
-		kind: payload.kind,
-		sig: payload.sig,
-		enc: payload.enc,
-		bridge: payload.bridge,
-		provisional: payload.provisional,
-		issued_at: payload.issued_at
-	};
-}
-/** What the signed order `pair.offer` covers. */
-function pairOfferRecord(input) {
-	return {
-		t: TRUST_SIGNATURE_TAGS.pairOffer,
-		kind: input.kind,
-		bridge: input.bridge,
-		x: input.order.x,
-		expires_at: input.order.expires_at
-	};
-}
-/** What the authorization of a `device.revoked` signs. */
-function deviceRevokedRecord(payload) {
-	return {
-		t: TRUST_SIGNATURE_TAGS.deviceRevoked,
-		device: payload.device,
-		chain_head: payload.chain_head,
-		issued_at: payload.issued_at,
-		author: payload.author
-	};
-}
-/** What the authorization of a `device.root_certified` signs. */
-function rootCertifiedRecord(payload) {
-	return {
-		t: TRUST_SIGNATURE_TAGS.rootCertified,
-		root: payload.root,
-		issued_at: payload.issued_at
-	};
-}
 //#endregion
 //#region ../../packages/protocol/dist/elicitation.js
 /**
@@ -6346,14 +7638,18 @@ const DEFAULT_MERGE_METHOD = "merge";
 * 3.28: `forge`, a merge the creator did on the forge itself (the pull request merged by hand),
 * which the engine recorded from what the forge shows: no approval to wait for, the forge's own
 * event is the proof (who merged it, when, on which commit). `agent`, the merge the
-* agent responsible decided because the creator did not keep the merges for themselves.
+* agent responsible decided because the creator did not keep the merges for themselves. `web`, the
+* merge the machine did once the signed order of a browser the creator trusts was carried out, in
+* the same write as that answer; `mobile`, the same for the signed order of a phone.
 */
 const MERGE_SOURCES = [
 	"chat",
 	"elicitation",
 	"terminal",
 	"forge",
-	"agent"
+	"agent",
+	"web",
+	"mobile"
 ];
 /** Most changed files one merge records (the knowledge base reads them). */
 const MAX_MERGED_FILES = 1e3;
@@ -6766,6 +8062,273 @@ const LoopInputSchema = z.strictObject({
 	message: "a story goes with an approach (note) or a result (seen), and only with them",
 	path: ["story"]
 });
+const ProductStageSchema = z.enum([
+	"framing",
+	"development",
+	"launch",
+	"online"
+]);
+/** How a product starts: from an idea (no repository), from a repository already on the machine, or from an empty repository. */
+const PRODUCT_STARTS = [
+	"idea",
+	"existing",
+	"empty"
+];
+/** What a machine says of the repository of a product: none, one it made empty, or one that was already there. */
+const PRODUCT_REPOSITORIES = [
+	"none",
+	"empty",
+	"existing"
+];
+const PRODUCT_IDEA_MAX = 4e3;
+/** The longest folder path a machine tells of a product (the full path on the machine). */
+const PRODUCT_FOLDER_PATH_MAX = 1e3;
+/** The identifier of a place a machine allows products in (`home`, `place-2`): the machine names it, the device only repeats it. */
+const PRODUCT_LOCATION_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const hasControl = (value) => [...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127);
+/** A name the creator gives a product: trimmed, one line, no control character. */
+function isProductName(value) {
+	return value.length >= 1 && value.length <= 80 && value === value.trim() && !hasControl(value);
+}
+/**
+* A folder name inside a place the machine allows: one segment, never a path. It holds no
+* separator, no drive or stream mark, no control character, is not `.` or `..`, and does not end
+* with a dot or a space (which a system may drop silently).
+*/
+function isFolderName(value) {
+	return value.length >= 1 && value.length <= 100 && value !== "." && value !== ".." && !/[\\/:*?"<>|]/.test(value) && !hasControl(value) && !/[. ]$/.test(value);
+}
+/**
+* A step of the way into a place: one folder name, never a path, and never a hidden one (a name
+* that starts with a dot). The machine resolves the steps itself and refuses what leaves the place.
+*/
+function isBrowseStep(value) {
+	return isFolderName(value) && !value.startsWith(".");
+}
+z.strictObject({
+	name: z.string().refine(isProductName, { message: "a name of one line, trimmed" }),
+	start: z.enum(PRODUCT_STARTS),
+	location: z.string().regex(PRODUCT_LOCATION_ID_PATTERN),
+	folder: z.string().refine(isFolderName, { message: "a folder name, not a path" }).optional(),
+	/** The folders to go through inside the place, one name each (as the machine listed them), to make the product there. */
+	path: z.array(z.string().refine(isBrowseStep, { message: "a folder name, not a path" })).max(12).optional(),
+	preset: z.enum(PROFILE_PRESET_IDS),
+	stage: ProductStageSchema,
+	idea: z.string().min(1).max(PRODUCT_IDEA_MAX).optional()
+}).superRefine((params, context) => {
+	if (params.start === "existing" && params.folder === void 0) context.addIssue({
+		code: "custom",
+		path: ["folder"],
+		message: "a repository to take"
+	});
+	if (params.start === "existing" && params.path !== void 0) context.addIssue({
+		code: "custom",
+		path: ["path"],
+		message: "not for an existing one"
+	});
+	if (params.start !== "existing" && params.folder !== void 0) context.addIssue({
+		code: "custom",
+		path: ["folder"],
+		message: "only for an existing one"
+	});
+	if (params.start !== "idea" && params.idea !== void 0) context.addIssue({
+		code: "custom",
+		path: ["idea"],
+		message: "only with an idea"
+	});
+});
+z.strictObject({});
+z.strictObject({
+	stage: ProductStageSchema.optional(),
+	paused: z.boolean().optional(),
+	archived: z.boolean().optional()
+}).refine((params) => Object.keys(params).length > 0, { message: "at least one mark" });
+z.strictObject({ profile: ProfileSchema });
+/** What a machine says of the place it allows products in. */
+const ProductLocationSchema = z.strictObject({
+	id: z.string().regex(PRODUCT_LOCATION_ID_PATTERN),
+	/** The folder as the creator reads it (the home folder written `~`). */
+	label: z.string().min(1).max(200),
+	/** The folders of this place that hold a repository and no product yet: ones to start from. */
+	folders: z.array(z.string().refine(isFolderName)).max(50),
+	/** True for the place the creator chose the last time (the one to propose first). */
+	last: z.literal(true).optional()
+});
+/**
+* A creation the machine is making, has made or could not make. It is told by its ticket (the
+* reference the order answered with); a finished one names the product it made. A finished or
+* failed one stays a few minutes in the report, so that a device that was away still learns it.
+*/
+const ProductCreationSchema = z.strictObject({
+	id: UlidSchema,
+	name: z.string().min(1).max(80),
+	state: z.enum([
+		"running",
+		"done",
+		"failed"
+	]),
+	/** The product made, once `done`. */
+	product: UlidSchema.optional(),
+	/** Why it failed. */
+	code: z.enum([
+		"folder",
+		"repository",
+		"engine",
+		"link"
+	]).optional()
+});
+/** The marks and the profile a machine reports for a product it serves. */
+const ProductLifeSchema = z.strictObject({
+	stage: ProductStageSchema.optional(),
+	paused: z.literal(true).optional(),
+	archived: z.literal(true).optional(),
+	repository: z.enum(PRODUCT_REPOSITORIES).optional(),
+	/** The full path of the product's folder on this machine: told to the creator's own devices only, never published. */
+	folder: z.string().min(1).max(PRODUCT_FOLDER_PATH_MAX).optional(),
+	profile: ProfileSchema.optional(),
+	autonomy: ProductAutonomySchema.optional()
+});
+//#endregion
+//#region ../../packages/protocol/dist/tolerant-reader.js
+const cache = /* @__PURE__ */ new WeakMap();
+const defOf = (schema) => schema._zod.def;
+const cloneWith = (schema, def) => schema.clone(def);
+function derive(schema) {
+	const def = defOf(schema);
+	switch (def.type) {
+		case "object": {
+			const shape = def.shape;
+			const next = {};
+			for (const key of Object.keys(shape)) next[key] = readTolerant(shape[key]);
+			return cloneWith(schema, {
+				...def,
+				shape: next,
+				catchall: void 0
+			});
+		}
+		case "array": return cloneWith(schema, {
+			...def,
+			element: readTolerant(def.element)
+		});
+		case "optional":
+		case "nullable":
+		case "readonly":
+		case "default":
+		case "prefault":
+		case "nonoptional":
+		case "catch": return cloneWith(schema, {
+			...def,
+			innerType: readTolerant(def.innerType)
+		});
+		case "union": return cloneWith(schema, {
+			...def,
+			options: def.options.map((option) => readTolerant(option))
+		});
+		case "record": return cloneWith(schema, {
+			...def,
+			valueType: readTolerant(def.valueType)
+		});
+		case "tuple": return cloneWith(schema, {
+			...def,
+			items: def.items.map((item) => readTolerant(item))
+		});
+		case "pipe": return cloneWith(schema, {
+			...def,
+			in: readTolerant(def.in),
+			out: readTolerant(def.out)
+		});
+		default: return schema;
+	}
+}
+/** The same schema, reading what a device receives: unknown keys dropped, known ones as strict as before. */
+function readTolerant(schema) {
+	const known = cache.get(schema);
+	if (known !== void 0) return known;
+	const derived = derive(schema);
+	cache.set(schema, derived);
+	return derived;
+}
+//#endregion
+//#region ../../packages/protocol/dist/machines.js
+/**
+* Several machines for one account: what a machine says about itself (end-to-end encrypted, the
+* relay never reads it), the choice of a product's main bridge, and the rules that route an order.
+*
+* Generic on purpose: schemas and small pure rules only, no transport and no account.
+*
+* Reading rule: a device ignores the optional fields of a report it does not know and validates
+* those it knows (`MachineReportReader`); an order a machine receives stays strict.
+*/
+/** Event types of the machines, each at version 1. */
+const MACHINE_EVENT_TYPES = { 
+/** The main bridge of the product changed: written by the machine that becomes main. */
+primaryChanged: "bridge.primary_changed" };
+/**
+* `payload` of `bridge.primary_changed`: the bridge that is now the product's main one, and the
+* one that was (null for the first choice). Only the last one in projection order counts.
+*/
+const PrimaryChangedPayloadSchema = z.strictObject({
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	previous: z.string().regex(BRIDGE_ID_PATTERN).nullable()
+});
+/** One AI tool the bridge detected on its machine, and how it is integrated. */
+const DetectedToolSchema = z.strictObject({
+	tool: z.string().min(1).max(40),
+	/** The integration mode, in plain words (never a path). */
+	mode: z.string().min(1).max(60),
+	active: z.boolean()
+});
+/**
+* What a bridge says of its machine, inside its end-to-end encrypted beat: its version, the
+* protocol version it speaks, the products it serves (names the creator knows), how many agent
+* instances run (an instance is an agent on a story), the tools it detected and the role the
+* creator gave it. The relay sees none of it.
+*/
+const MachineReportSchema = z.strictObject({
+	/** The name the machine goes by (its host name unless the creator changed it). */
+	name: z.string().min(1).max(60),
+	bridge_version: SemverSchema,
+	protocol_version: z.number().int().positive(),
+	products: z.array(z.strictObject({
+		id: z.string().min(1).max(80),
+		name: z.string().min(1).max(80),
+		/** The creator's priority for this product (1 first); absent while they gave none. */
+		rank: z.int().min(1).max(9999).optional(),
+		/** The marks the creator gave it (stage, pause, archive), its repository and its profile. */
+		...ProductLifeSchema.shape
+	})).max(64),
+	agents: z.number().int().nonnegative(),
+	tools: z.array(DetectedToolSchema).max(64),
+	role: z.string().max(120).optional(),
+	/**
+	* The names of the tokens and logins the creator gave this machine (`forge.github`,
+	* `data.crm`), never their values: what to renew at the platforms if the machine is lost. Only
+	* present when there is at least one.
+	*/
+	secrets: z.array(z.string().regex(/^(?:forge|data)\.[a-z0-9][a-z0-9._-]{0,63}$/)).max(64).optional(),
+	/**
+	* The code platforms this machine is linked to (or being linked to): who, how far, until when.
+	* Never a token. Only present when there is at least one.
+	*/
+	forges: z.array(ForgeLinkStatusSchema).max(16).optional(),
+	/**
+	* Where this machine keeps its keys: the system keychain, or the fallback store of a machine
+	* that has none (a server). Absent from a bridge that does not say.
+	*/
+	key_store: z.enum(["system", "fallback"]).optional(),
+	/**
+	* The places this machine allows new products in, with the repositories already there that a
+	* product can start from. Only present on a machine that can create products.
+	*/
+	locations: z.array(ProductLocationSchema).max(8).optional(),
+	/** The products this machine is creating or failed to create. Only present when there is one. */
+	creations: z.array(ProductCreationSchema).max(8).optional()
+});
+readTolerant(MachineReportSchema);
+z.strictObject({
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	role: z.string().max(120)
+});
 //#endregion
 //#region ../../packages/protocol/dist/merge-order.js
 /**
@@ -6927,6 +8490,196 @@ const MethodMigratedPayloadSchema = z.strictObject({
 	steps: z.array(MigrationStepIdSchema).max(1e3)
 }).refine((payload) => payload.to_format >= payload.from_format, { path: ["to_format"] }).refine((payload) => payload.steps.length === payload.to_format - payload.from_format, { path: ["steps"] }).refine((payload) => payload.to_format !== payload.from_format || payload.from_engine !== payload.to_engine, { path: ["to_engine"] });
 //#endregion
+//#region ../../packages/protocol/dist/orders.js
+/**
+* Signed orders: every command sent to a machine is signed by the device of the creator that gives
+* it, and the bridge that receives it checks it with the key its journal registers for that
+* device, never with a key the relay supplied. An order is one JSON object; the signature covers
+* its canonical form (RFC 8785) without the signature itself, `t` included. `t` names the order
+* type and its version (`order.pair.offer/v1`), so that a signature made for an order is never
+* taken for an authorization, a message or an event, and conversely.
+*
+* Adding an order type means declaring its parameters, its target and its risk level in an
+* `OrderTypeRegistry`; no check below changes.
+*/
+/** Event type the bridge writes once an order is applied: it keeps the signed order. */
+const ORDER_EVENT_TYPES = {
+	applied: "order.applied",
+	/** A signed order the bridge refused: the journal keeps who gave it and why it was refused. */
+	rejected: "order.rejected"
+};
+/** Orders are signed with Ed25519 only. */
+const ORDER_ALG = DEVICE_SIG_ALG;
+/** The label of the receipt a bridge signs for an order. */
+const ORDER_RECEIPT_TAG = "order.receipt/v1";
+const ORDER_TAG = /^order\.([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*)\/v([1-9][0-9]{0,2})$/;
+/** The codes a bridge answers an order with, in the order the bridge applies its checks. */
+const ORDER_ERROR_CODES = {
+	INVALID_ORDER: "INVALID_ORDER",
+	UPGRADE_REQUIRED: ErrorCode.UPGRADE_REQUIRED,
+	UNKNOWN_DEVICE: "UNKNOWN_DEVICE",
+	SIGNATURE_INVALID: ErrorCode.SIGNATURE_INVALID,
+	SECURITY_ROOT_CHANGED: ErrorCode.SECURITY_ROOT_CHANGED,
+	DEVICE_REVOKED: "DEVICE_REVOKED",
+	WRONG_BRIDGE: "WRONG_BRIDGE",
+	ORDER_EXPIRED: "ORDER_EXPIRED",
+	ORDER_REPLAYED: "ORDER_REPLAYED",
+	NOT_OWNER: "NOT_OWNER",
+	STALE_BASIS: "STALE_BASIS",
+	/** Two orders on the same target: the first one applied wins, the second gets this. */
+	ALREADY_RESOLVED: "ALREADY_RESOLVED"
+};
+ORDER_ERROR_CODES.INVALID_ORDER, ORDER_ERROR_CODES.UPGRADE_REQUIRED, ORDER_ERROR_CODES.UNKNOWN_DEVICE, ORDER_ERROR_CODES.SIGNATURE_INVALID, ORDER_ERROR_CODES.SECURITY_ROOT_CHANGED, ORDER_ERROR_CODES.DEVICE_REVOKED, ORDER_ERROR_CODES.WRONG_BRIDGE, ORDER_ERROR_CODES.ORDER_EXPIRED, ORDER_ERROR_CODES.ORDER_REPLAYED, ORDER_ERROR_CODES.NOT_OWNER, ORDER_ERROR_CODES.STALE_BASIS, ORDER_ERROR_CODES.ALREADY_RESOLVED;
+/** `sha256:` then the digest in base64url: the fingerprint of what the creator saw. */
+const ORDER_BASIS_PATTERN = TRUST_EVENT_HASH_PATTERN;
+z.strictObject({
+	path: z.string().min(1).max(1024),
+	branch: z.string().min(1).max(255),
+	blob_sha: z.string().regex(/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/)
+});
+const utcDatetime = z.iso.datetime();
+/**
+* An order, as it travels. `params` is checked again by the schema of its type (a registry
+* declares it); here it is only a JSON object.
+*/
+const OrderSchema = z.strictObject({
+	/** `order.<type>/v<version>`. */
+	t: z.string().regex(ORDER_TAG),
+	id: UlidSchema,
+	/** The device of the creator that signs the order. */
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	/** The bridge the order is for. */
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	product: UlidSchema,
+	/** The story the order is about, or null. */
+	target: z.string().min(1).max(120).nullable(),
+	/** The fingerprint of the state and documents the creator saw, or null. */
+	basis: z.string().regex(ORDER_BASIS_PATTERN).nullable(),
+	/** The device's own counter: strictly increasing, one per order the device signs. */
+	seq: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+	issued_at: utcDatetime,
+	expires_at: utcDatetime,
+	params: z.record(z.string(), z.unknown()),
+	alg: z.literal(ORDER_ALG),
+	sig: Ed25519SignatureSchema
+}).refine((order) => Date.parse(order.expires_at) > Date.parse(order.issued_at), {
+	path: ["expires_at"],
+	message: "an order expires after it is issued"
+}).refine((order) => jsonValueIssue(order.params) === void 0, {
+	path: ["params"],
+	message: "params are JSON"
+});
+z.strictObject({
+	t: z.literal(ORDER_RECEIPT_TAG),
+	order: UlidSchema,
+	/** The device that gave the order: the receipt is for it only. */
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	product: UlidSchema,
+	outcome: z.enum(["applied", "rejected"]),
+	/** The code the emitting device sees (never `UNKNOWN_DEVICE`); present when rejected. */
+	code: z.string().regex(/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/).optional(),
+	/**
+	* A simple handle on what an applied order made (never its content): for a secret, the
+	* reference under which the machine keeps it.
+	*/
+	reference: z.string().min(1).max(128).optional(),
+	at: utcDatetime,
+	alg: z.literal(ORDER_ALG),
+	sig: Ed25519SignatureSchema
+}).refine((receipt) => receipt.outcome === "rejected" === (receipt.code !== void 0), {
+	path: ["code"],
+	message: "a rejected receipt names its code, an applied one has none"
+}).refine((receipt) => receipt.reference === void 0 || receipt.outcome === "applied", {
+	path: ["reference"],
+	message: "only an applied receipt carries a reference"
+}).refine((receipt) => receipt.code !== ORDER_ERROR_CODES.UNKNOWN_DEVICE, {
+	path: ["code"],
+	message: "the external code never tells that a device is unknown"
+});
+/** Where an order was given from, as the bridge knows it from the device's kind in its registry. */
+const ORDER_SOURCES = [
+	"web",
+	"mobile",
+	"machine"
+];
+/** `payload` of `order.applied` v1: the signed order, kept so that anyone can check it without the bridge. */
+const OrderAppliedPayloadSchema = z.strictObject({
+	order: OrderSchema,
+	/** The emitting device (the order's own `device`). */
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	/** Fixed by the way in (the kind of device in the registry), never read from the order. */
+	source: z.enum(ORDER_SOURCES),
+	applied_at: utcDatetime
+});
+/**
+* `payload` of `order.rejected` v1: an order whose signature checked out and that the bridge did
+* not apply, with the code the creator sees (never `UNKNOWN_DEVICE`). It carries no `params`: a
+* refusal is a fact, not a second copy of the order.
+*/
+const OrderRejectedPayloadSchema = z.strictObject({
+	order: UlidSchema,
+	/** `order.<type>/v<version>`. */
+	t: z.string().regex(ORDER_TAG),
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	code: z.string().regex(/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/),
+	source: z.enum(ORDER_SOURCES),
+	rejected_at: utcDatetime
+});
+/**
+* A link or a QR code for one more browser or phone: the rendezvous and the secret the device drew,
+* and the device's own signature of the authorization the bridge will write `device.paired` on
+* (`offer_sig`, over the `pair.offer` record of the kind of device, this bridge, `x` and `expires_at`).
+*/
+const PairOfferLinkParamsSchema = z.strictObject({
+	kind: z.enum(["link", "phone"]),
+	x: z.string().length(22).refine(isCanonicalBase64url),
+	s: z.string().length(22).refine(isCanonicalBase64url),
+	expires_at: utcDatetime,
+	offer_sig: Ed25519SignatureSchema
+});
+/** The short code of another machine: an address of 8 symbols and a password of 6. */
+const PairOfferCodeParamsSchema = z.strictObject({
+	kind: z.literal("machine"),
+	x: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{8}$/),
+	w: z.string().regex(/^[0-9A-HJKMNP-TV-Z]{6}$/),
+	expires_at: utcDatetime,
+	offer_sig: Ed25519SignatureSchema
+});
+z.union([PairOfferLinkParamsSchema, PairOfferCodeParamsSchema]);
+z.strictObject({ heads: z.record(z.string().regex(BRIDGE_ID_PATTERN), z.string().regex(TRUST_EVENT_HASH_PATTERN)).refine((heads) => Object.keys(heads).length <= 64, { message: "at most 64 writers" }) });
+z.strictObject({ role: z.string().max(120) });
+z.strictObject({});
+/** The kinds of connection a secret belongs to, and the shape of its name (`forge.github`, `data.crm`). */
+const SECRET_NAME_PATTERN = /^(?:forge|data)\.[a-z0-9][a-z0-9._-]{0,63}$/;
+/** The longest sealed box of a secret, as text: the secret in UTF-8 (4 bytes a character), its envelope and the box's own. */
+const SEALED_SECRET_MAX_CHARS = Math.ceil(262784 / 3) + 80;
+z.strictObject({
+	name: z.string().regex(SECRET_NAME_PATTERN),
+	sealed: z.string().min(1).max(SEALED_SECRET_MAX_CHARS).regex(/^[A-Za-z0-9_-]+$/)
+});
+z.strictObject({ ranks: z.record(UlidSchema, z.int().min(1).max(9999)).refine((all) => Object.keys(all).length <= 64, { message: "at most 64 products" }) });
+/**
+* The creator removes a device (a phone, a browser or a machine, possibly the one that gives the
+* order). The device signs the `device.revoked` authorization the bridge will write on its
+* authority (over the record of the removed device, the head of its chain, the date and the
+* author, which is the device that gives the order), so that the journal proves who removed what
+* without the bridge's word. `chain_head` is the last event of a removed machine's chain the author
+* saw in a product's journal (each journal has its own chain), null for a phone or a browser.
+* `authorizations` holds one signature per product the author saw the machine in, and `*` for any
+* other product (always with a null head). The order is for the bridge that applies it, which
+* writes the removal in every product it serves.
+*/
+const RevocationAuthorizationSchema = z.strictObject({
+	chain_head: z.string().regex(TRUST_EVENT_HASH_PATTERN).nullable(),
+	sig: Ed25519SignatureSchema
+});
+z.strictObject({
+	device: z.string().regex(PAIRED_DEVICE_ID_PATTERN),
+	issued_at: utcDatetime,
+	authorizations: z.record(z.string().refine((key) => key === "*" || ULID_PATTERN.test(key), { message: "a product identifier or *" }), RevocationAuthorizationSchema).refine((all) => "*" in all && all["*"]?.chain_head === null, { message: "the authorization for any product has no chain head" }).refine((all) => Object.keys(all).length <= 65, { message: "at most 64 products" })
+});
+//#endregion
 //#region ../../packages/protocol/dist/product-key.js
 /**
 * The product key: a symmetric key of 32 random bytes, kept in the system keychain of
@@ -6936,12 +8689,21 @@ const MethodMigratedPayloadSchema = z.strictObject({
 * written: by `product.key_created` in the journal, and in each encrypted value.
 */
 /** Event types of the product key, each at version 1. */
-const PRODUCT_KEY_EVENT_TYPES = { 
-/** The product key was created: its `key_id`, signed by the machine that created it. */
-keyCreated: "product.key_created" };
+const PRODUCT_KEY_EVENT_TYPES = {
+	/** The product key was created: its `key_id`, signed by the machine that created it. */
+	keyCreated: "product.key_created",
+	/**
+	* The product key was renewed: a new key follows the one named by `previous_key_id`. The old key
+	* stays valid for reading everything written before; only new content is written under the new
+	* one. Each trusted machine gets the new key in a box sealed for its own encryption key.
+	*/
+	keyRotated: "product.key_rotated"
+};
 /** `pk:` then the first 16 base64url characters of the key's `apkeyid1` subkey (`crypto_kdf`). */
 const KEY_ID_PATTERN = /^pk:[A-Za-z0-9_-]{16}$/;
 const KeyIdSchema = z.string().regex(KEY_ID_PATTERN);
+/** 32 bytes in base64url: 43 characters, the last one carrying 4 bits only. */
+const PROOF_PATTERN = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
 /**
 * `payload` of `product.key_created`: the `key_id`, and the `proof` that its writer held the key
 * (keyed BLAKE2b of `agentplugged/key-proof/v1\0` + the product id, by the key's `approof1`
@@ -6949,7 +8711,33 @@ const KeyIdSchema = z.string().regex(KEY_ID_PATTERN);
 */
 const ProductKeyCreatedPayloadSchema = z.strictObject({
 	key_id: KeyIdSchema,
-	proof: z.string().regex(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/)
+	proof: z.string().regex(PROOF_PATTERN)
+});
+/** A trusted machine's identifier, the name of its box in a renewal. */
+const MACHINE_BOX_OWNER = /^machine:[A-Za-z0-9_-]{16}$/;
+/** A sealed box (libsodium `crypto_box_seal`) in base64url: at most 256 characters. */
+const KEY_BOX = z.string().regex(/^[A-Za-z0-9_-]{60,256}$/);
+/**
+* `payload` of `product.key_rotated`: the new `key_id`, the key it follows, the `proof` that the
+* writer held the new key (the same proof as the first announcement), and `boxes`: the new key
+* sealed, one box per trusted machine, for that machine's encryption key. No key is ever in clear.
+*/
+const ProductKeyRotatedPayloadSchema = z.strictObject({
+	key_id: KeyIdSchema,
+	previous_key_id: KeyIdSchema,
+	proof: z.string().regex(PROOF_PATTERN),
+	/**
+	* The proof that the writer held the key this one follows (made with that key, for this renewal
+	* only): a machine that holds the previous key ignores a renewal that does not carry it.
+	*/
+	chain_proof: z.string().regex(PROOF_PATTERN),
+	/**
+	* The signed order that asked for the renewal, when it came from a creator's device: the
+	* `order.applied` of the same journal keeps that order. A renewal run again for the same order
+	* is recognised by it and not made twice.
+	*/
+	order: z.string().regex(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/).optional(),
+	boxes: z.record(z.string().regex(MACHINE_BOX_OWNER), KEY_BOX).refine((boxes) => Object.keys(boxes).length <= 64, { message: `at most 64 boxes` })
 });
 /** The algorithm of `payload_enc` and of the sensitive files: XChaCha20-Poly1305 (IETF). */
 const PAYLOAD_ENCRYPTION_ALG = "xchacha20poly1305";
@@ -6970,6 +8758,8 @@ const MAX_SENSITIVE_CONTENT_BYTES = 262144;
 const ENCRYPTED_FILE_PREFIX = "agentplugged-enc:1:";
 /** Prefix of an exported product key (`key export`). */
 const PRODUCT_KEY_EXPORT_PREFIX = "apk1:";
+/** Prefix of an export that holds several keys: the current one first, then the older ones. */
+const PRODUCT_KEYS_EXPORT_PREFIX = "apk2:";
 /** Why a path given to a sensitive file tool is refused. */
 const PATH_MESSAGE = "expected a relative path inside the area (`/` between names; no `..`, `.`, empty name, drive, reserved character or Windows device name; no name ending with a dot or a space)";
 /** A file name part: no control character, no character Windows refuses, not `.` or `..`. */
@@ -7043,8 +8833,8 @@ const READINESS_GESTURES = ["fix", "accept"];
 /** The option of the decision a blocking verdict opens by which the creator goes on all the same. */
 const READINESS_GO_ON = "go_on";
 const READINESS_FIX_FIRST = "fix_first";
-const NO_CONTROL$2 = { message: "expected no control character" };
-const lineText$2 = (max) => z.string().trim().min(1).max(max).refine((text) => !/[\r\n]/.test(text), { message: "expected a single line" }).refine((text) => !hasControlCharacter(text, false), NO_CONTROL$2);
+const NO_CONTROL$1 = { message: "expected no control character" };
+const lineText$2 = (max) => z.string().trim().min(1).max(max).refine((text) => !/[\r\n]/.test(text), { message: "expected a single line" }).refine((text) => !hasControlCharacter(text, false), NO_CONTROL$1);
 /**
 * One judged finding as the report gives it. `passages` are `<document>: <passage>`: the document
 * by its id or its file name, then a heading or an identifier (`EF-n`, `ENF-n`, `PU-n`, `AD-n`) it
@@ -7395,8 +9185,8 @@ const REGULATED_FIELDS = [
 	"health",
 	"finance"
 ];
-const NO_CONTROL$1 = { message: "expected no control character" };
-const lineText$1 = (max) => z.string().trim().min(1).max(max).refine((text) => !/[\r\n]/.test(text), { message: "expected a single line" }).refine((text) => !hasControlCharacter(text, false), NO_CONTROL$1);
+const NO_CONTROL = { message: "expected no control character" };
+const lineText$1 = (max) => z.string().trim().min(1).max(max).refine((text) => !/[\r\n]/.test(text), { message: "expected a single line" }).refine((text) => !hasControlCharacter(text, false), NO_CONTROL);
 /** A guest's identifier: `guest-` and a slug, so it is never mistaken for an agent of the team. */
 const GuestIdSchema = z.string().max(48).regex(/^guest-[a-z0-9]+(?:-[a-z0-9]+)*$/);
 /** A saved room's identifier: the name of its files. */
@@ -7769,117 +9559,38 @@ const ReviewTestsCheckSchema = z.strictObject({
 const ReviewTestsInputSchema = z.strictObject({
 	agent: AgentIdSchema.max(64),
 	story: StoryIdSchema.optional(),
-	check: ReviewTestsCheckSchema.optional()
-});
-/** `payload` of `tests.reviewed`: the marks, and what the mutation check found. */
-const TestsReviewedPayloadSchema = z.strictObject({
-	story: StoryIdSchema.optional(),
-	commit: CommitIdSchema.optional(),
-	score: z.number().int().min(0).max(100).optional(),
-	grade: z.enum([
-		"A",
-		"B",
-		"C",
-		"D",
-		"F"
-	]).optional(),
-	verdict: z.enum([
-		"sound",
-		"to_improve",
-		"to_fix",
-		"blocked"
-	]).optional(),
-	criteria: z.array(z.strictObject({
-		criterion: z.enum(TEST_CRITERIA),
-		score: z.number().int().min(0).max(100)
-	})).max(TEST_CRITERIA.length).optional(),
-	findings: z.number().int().min(0).max(60).optional(),
-	mutation: z.strictObject({
-		ran: z.number().int().min(0).max(30),
-		killed: z.number().int().min(0).max(30),
-		survived: z.number().int().min(0).max(30)
-	}).optional(),
-	gaps: z.number().int().min(0).max(1e3)
-});
-//#endregion
-//#region ../../packages/protocol/dist/trace.js
-/**
-* Traceability and deviations. Each requirement of the PRD (`EF-n`, `ENF-n`) is linked,
-* at read time, to the stories that cite it, their pull requests, the tests that cite it and the
-* deviations recorded on it: nothing of that link is ever written in a document. A deviation is a
-* signed event of the journal: an agent (the QA reviewer) found the delivered work drifting from
-* requirements a started story cites. Its id, like an item of deferred work's, is `V-` then the
-* last 10 characters of the ULID of its event, never written in the `payload`, never reused.
-*/
-/** Event types of the deviations, each at version 1. */
-const DEVIATION_EVENT_TYPES = {
-	reported: "deviation.reported",
-	resolved: "deviation.resolved"
-};
-/** Where a requirement stands: to do, in development, in review, delivered, or deviating. */
-const REQUIREMENT_STATUSES = [
-	"todo",
-	"in_development",
-	"in_review",
-	"delivered",
-	"deviation"
-];
-/** The requirements traced: the functional and non-functional ones of the PRD. */
-const TRACED_REQUIREMENT_PATTERN = /^(?:EF|ENF)-[1-9]\d*$/;
-/** A traced requirement as typed (`ef-18`, with spaces): trimmed, in upper case, then checked. */
-const TracedRequirementInputSchema = z.string().trim().toUpperCase().pipe(z.string().regex(TRACED_REQUIREMENT_PATTERN, { message: "expected EF-n or ENF-n, for example EF-18" }));
-/** `V-` then the last 10 characters of the ULID of the event that reported the deviation. */
-const DeviationIdSchema = z.string().regex(/^V-[0-9A-HJKMNP-TV-Z]{10}$/, { message: "expected V- then 10 characters, for example V-7M2K9QX4TB" });
-/** An id as typed (`v-7m2k9qx4tb`, with spaces): trimmed and in upper case, then checked. */
-const DeviationIdInputSchema = z.string().trim().toUpperCase().pipe(DeviationIdSchema);
-/** The id of the deviation reported by the event `eventId`: stable, never renumbered. */
-function deviationIdOf(eventId) {
-	return `V-${eventId.slice(-10)}`;
-}
-const NO_CONTROL = { message: "expected no control character" };
-const SummarySchema = z.string().trim().min(1).max(200).refine((summary) => !/[\r\n]/.test(summary), { message: "expected a single line" }).refine((summary) => !hasControlCharacter(summary, false), NO_CONTROL);
-const DetailSchema = z.string().trim().min(1).max(2e3).refine((detail) => !hasControlCharacter(detail, true), NO_CONTROL);
-const ReasonSchema = z.string().trim().min(1).max(1e3).refine((reason) => !hasControlCharacter(reason, true), NO_CONTROL);
-const RequirementIdSchema = z.string().regex(REQUIREMENT_ID_PATTERN, { message: "expected a requirement id (EF-n, ENF-n, PU-n, MS-n or AD-n)" });
-const requirementsOf = (id) => z.array(id).min(1).max(20).refine((ids) => new Set(ids).size === ids.length, { message: "requirements must differ" });
-/**
-* `payload` of `deviation.reported`. The story is the envelope's (required); `pr` is the number of
-* the story's pull request when the deviation was reported, set by the engine from the journal.
-*/
-const DeviationReportedPayloadSchema = z.strictObject({
-	requirements: requirementsOf(RequirementIdSchema),
-	summary: SummarySchema,
-	detail: DetailSchema.optional(),
-	pr: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).optional(),
-	/** The commit compared with the requirements. */
-	commit: CommitIdSchema.optional()
-});
-/** `payload` of `deviation.resolved`: the deviation, and how it was fixed or why it is lifted. */
-const DeviationResolvedPayloadSchema = z.strictObject({
-	deviation: DeviationIdSchema,
-	reason: ReasonSchema
-});
-/** A requirement id as typed: in upper case, then checked. */
-const RequirementInputSchema = z.string().trim().toUpperCase().pipe(RequirementIdSchema);
-/** Input of `report_deviation`: the story brought to its canonical form. */
-const ReportDeviationInputSchema = z.strictObject({
-	agent: AgentIdSchema.max(64),
-	story: StoryIdSchema.overwrite(canonicalStoryId),
-	requirements: requirementsOf(RequirementInputSchema),
-	summary: SummarySchema,
-	detail: DetailSchema.optional(),
-	commit: CommitIdSchema.optional()
-});
-/** Input of `lift_deviation`: the agent that reported it lifts it, with why. */
-const ResolveDeviationInputSchema = z.strictObject({
-	agent: AgentIdSchema.max(64),
-	deviation: DeviationIdInputSchema,
-	reason: ReasonSchema
+	check: ReviewTestsCheckSchema.optional()
+});
+/** `payload` of `tests.reviewed`: the marks, and what the mutation check found. */
+const TestsReviewedPayloadSchema = z.strictObject({
+	story: StoryIdSchema.optional(),
+	commit: CommitIdSchema.optional(),
+	score: z.number().int().min(0).max(100).optional(),
+	grade: z.enum([
+		"A",
+		"B",
+		"C",
+		"D",
+		"F"
+	]).optional(),
+	verdict: z.enum([
+		"sound",
+		"to_improve",
+		"to_fix",
+		"blocked"
+	]).optional(),
+	criteria: z.array(z.strictObject({
+		criterion: z.enum(TEST_CRITERIA),
+		score: z.number().int().min(0).max(100)
+	})).max(TEST_CRITERIA.length).optional(),
+	findings: z.number().int().min(0).max(60).optional(),
+	mutation: z.strictObject({
+		ran: z.number().int().min(0).max(30),
+		killed: z.number().int().min(0).max(30),
+		survived: z.number().int().min(0).max(30)
+	}).optional(),
+	gaps: z.number().int().min(0).max(1e3)
 });
-/** The reason the creator gives at the terminal (`trace resolve`). */
-const DeviationReasonSchema = ReasonSchema;
-/** Input of `get_trace`: one requirement, or every one when absent. */
-const GetTraceInputSchema = z.strictObject({ requirement: z.string().max(32).optional() });
 //#endregion
 //#region ../../packages/protocol/dist/usage.js
 /**
@@ -8030,6 +9741,12 @@ const EVENT_TYPE_REGISTRY = {
 		version: currentVersionOf(AGENT_EVENT_TYPES.statusReported),
 		payload: StatusReportedPayloadSchema
 	},
+	/** An instruction of the creator to an agent: their own words, encrypted with the product key. */
+	[CHAIN_EVENT_TYPES.instructionGiven]: {
+		version: 1,
+		payload: InstructionGivenPayloadSchema,
+		sensitive: true
+	},
 	[AGENT_EVENT_TYPES.progressReported]: {
 		version: 1,
 		payload: ProgressReportedPayloadSchema
@@ -8075,6 +9792,10 @@ const EVENT_TYPE_REGISTRY = {
 		version: 1,
 		payload: ProductKeyCreatedPayloadSchema
 	},
+	[PRODUCT_KEY_EVENT_TYPES.keyRotated]: {
+		version: 1,
+		payload: ProductKeyRotatedPayloadSchema
+	},
 	/**
 	* The registry of trusted devices: a device paired, revoked, confirmed, the
 	* root certified by the first phone, and an alert dismissed by the creator. Clear: every
@@ -8100,6 +9821,21 @@ const EVENT_TYPE_REGISTRY = {
 		version: 1,
 		payload: TrustDismissedPayloadSchema
 	},
+	/** The main bridge of the product, chosen by the creator. */
+	[MACHINE_EVENT_TYPES.primaryChanged]: {
+		version: 1,
+		payload: PrimaryChangedPayloadSchema
+	},
+	/** An order a bridge applied, with the creator's signed order kept as the proof. */
+	[ORDER_EVENT_TYPES.applied]: {
+		version: 1,
+		payload: OrderAppliedPayloadSchema
+	},
+	/** A signed order a bridge refused, with the code the creator saw. */
+	[ORDER_EVENT_TYPES.rejected]: {
+		version: 1,
+		payload: OrderRejectedPayloadSchema
+	},
 	/** Reserved to tests: any payload. */
 	[TEST_EVENT_TYPE]: {
 		version: 1,
@@ -8310,6 +10046,26 @@ const EVENT_TYPE_REGISTRY = {
 		version: currentVersionOf(ELICITATION_EVENT_TYPES.answered),
 		payload: CheckpointElicitedPayloadSchema
 	},
+	/** The creator's answer carried by the signed order of a browser (the web view). */
+	[WEB_ANSWER_EVENT_TYPES.answered]: {
+		version: currentVersionOf(WEB_ANSWER_EVENT_TYPES.answered),
+		payload: CheckpointWebAnsweredPayloadSchema
+	},
+	/** An answer from the web held for the undo window: the point stays open meanwhile. */
+	[WEB_ANSWER_EVENT_TYPES.held]: {
+		version: currentVersionOf(WEB_ANSWER_EVENT_TYPES.held),
+		payload: CheckpointWebHeldPayloadSchema
+	},
+	/** A held answer taken back by the creator: the point was never answered. */
+	[WEB_ANSWER_EVENT_TYPES.holdCancelled]: {
+		version: 1,
+		payload: CheckpointWebHoldCancelledPayloadSchema
+	},
+	/** A held answer the machine could not carry out: released, the point is open again and says why. */
+	[WEB_ANSWER_EVENT_TYPES.holdFailed]: {
+		version: 1,
+		payload: CheckpointWebHoldFailedPayloadSchema
+	},
 	/** A story merged by the engine once the creator approved its merge checkpoint. */
 	[MERGE_EVENT_TYPES.merged]: {
 		version: currentVersionOf(MERGE_EVENT_TYPES.merged),
@@ -8481,6 +10237,437 @@ function currentEvent(event) {
 		event: current
 	};
 }
+/** The request shape (without the identifier, the version and the product, which the file reading adds). */
+const FindRequestFields = {
+	op: z.literal("find"),
+	query: z.string().min(1).max(120)
+};
+/** A place in a document where the words are: the document, its section, the line and the words around. */
+const FindHitSchema = z.strictObject({
+	/** The path from the product's folder, with `/`. */
+	path: z.string().min(1).max(300),
+	/** True for a page of the knowledge base (it opens in the knowledge base, not in the documents). */
+	kb: z.literal(true).optional(),
+	title: z.string().min(1).max(200),
+	/** The heading of the section, when it has one. */
+	heading: z.string().max(200).optional(),
+	/** The line of the document where the words are, from 1. */
+	line: z.int().min(1).max(1e7),
+	/** The line itself, cut around the words. */
+	snippet: z.string().min(1).max(240)
+});
+const FindDataSchema = z.strictObject({
+	op: z.literal("find"),
+	hits: z.array(FindHitSchema).max(8),
+	/** True when more documents hold the words than the answer lists. */
+	truncated: z.boolean(),
+	/** True when some document could not be read in full: the answer may miss some. */
+	incomplete: z.boolean().optional()
+});
+const KB_CLAIM_MAX_CHARS = 1200;
+/** The request shapes (without the identifier, the version and the product, which the file reading adds). */
+const KbListRequestFields = { op: z.literal("kb") };
+const KbAskRequestFields = {
+	op: z.literal("ask"),
+	/** Chosen by the device: asking again with it reads the same question's state, it never starts a second one. */
+	ask: z.string().regex(ULID_PATTERN),
+	question: z.string().min(1).max(800)
+};
+/** One page of the knowledge base. */
+const KbPageSchema = z.strictObject({
+	/** The path from the product's folder, with `/`. */
+	path: z.string().min(1).max(300),
+	title: z.string().min(1).max(200),
+	/** The first lines of the page, as written. */
+	summary: z.string().max(300).optional(),
+	/** The day the page says it was last updated (`2026-10-01`), when it says one. */
+	updated: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+	/** The last story the page says it took in (`2-3`), when it says one. */
+	story: z.string().regex(/^[1-9]\d{0,5}-[1-9]\d{0,5}$/).optional()
+});
+const KbListDataSchema = z.strictObject({
+	op: z.literal("kb"),
+	pages: z.array(KbPageSchema).max(200),
+	/** True when the product holds more pages than the bridge lists. */
+	truncated: z.boolean(),
+	/** True when some page could not be read in full: the list may miss some. */
+	incomplete: z.boolean().optional(),
+	/** Whether the machine can answer a question: an AI tool it knows how to run is there. */
+	askable: z.boolean()
+});
+/** A place of the base a statement stands on: the page, the section, the line and the words. */
+const KbCitationSchema = z.strictObject({
+	path: z.string().min(1).max(300),
+	/** The heading of the section the passage is in, when it has one. */
+	heading: z.string().max(200).optional(),
+	/** The line of the page where the quotation starts, from 1. */
+	line: z.int().min(1).max(1e7),
+	/** The words of the page, as they are written there. */
+	quote: z.string().min(1).max(300)
+});
+const KbClaimSchema = z.strictObject({
+	text: z.string().min(1).max(KB_CLAIM_MAX_CHARS),
+	/** At least one: a statement without a source that holds never leaves the bridge. */
+	citations: z.array(KbCitationSchema).min(1).max(4)
+});
+const KbCostSchema = z.strictObject({
+	usd: z.number().min(0).max(1e6).optional(),
+	basis: z.string().min(1).max(16),
+	tokens_in: z.int().min(0).max(1e9).optional(),
+	tokens_out: z.int().min(0).max(1e9).optional()
+});
+const KbAskDataSchema = z.strictObject({
+	op: z.literal("ask"),
+	ask: z.string().regex(ULID_PATTERN),
+	/** `working`: ask again; `answered`: the answer is below; `failed`: `failure` says why. */
+	state: z.enum([
+		"working",
+		"answered",
+		"failed"
+	]),
+	failure: z.string().min(1).max(32).optional(),
+	answer: z.strictObject({
+		claims: z.array(KbClaimSchema).max(12),
+		/** True when nothing in the base answers the question (or nothing that was said held). */
+		no_source: z.boolean(),
+		/** How many statements the bridge removed because no citation of theirs held. */
+		dropped: z.int().min(0).max(1e3)
+	}).optional(),
+	/** How many passages of the base the AI tool was given (0: it was not asked). */
+	passages: z.int().min(0).max(100),
+	cost: KbCostSchema.optional()
+});
+/** The local reference holding the last journal commit projected: never pushed. */
+const JOURNAL_PROJECTED_REF = "refs/agentplugged/projected";
+const IgnoredEventSchema = z.strictObject({
+	id: z.string(),
+	reason: z.enum([
+		"unknown_signer",
+		"bad_signature",
+		"broken_chain",
+		"wrong_product",
+		"invalid",
+		"key_conflict",
+		"product_conflict",
+		"test_type",
+		"checkpoint_id_collision",
+		"not_human",
+		"already_resolved",
+		"unendorsed_human",
+		"checkpoint_unknown",
+		"decrypt_failed",
+		"key_proof_invalid",
+		"sensitive_in_clear",
+		"unexpected_encryption",
+		"unsupported_alg",
+		"untrusted_authorization",
+		"device_revoked",
+		"dismissed",
+		"not_reopenable"
+	])
+});
+/** Two valid events of one device name the same `prev` (two clones on one machine): both kept. */
+const ChainForkWarningSchema = z.strictObject({
+	code: z.literal("chain_fork"),
+	device: z.string(),
+	prev: z.string().nullable(),
+	ids: z.array(z.string())
+});
+/**
+* Two `checkpoint.opened` events give the same checkpoint id: `ids[0]` opened it, the others are
+* ignored (`checkpoint_id_collision`).
+*/
+const CheckpointIdCollisionWarningSchema = z.strictObject({
+	code: z.literal("checkpoint_id_collision"),
+	checkpoint: z.string(),
+	ids: z.array(z.string())
+});
+/**
+* A signed `checkpoint.opened` asks a weaker recipient or confirmation than the rules give: the
+* projection applies the rules' values, and says so. `fields` names what was raised.
+*/
+const CheckpointWeakPayloadWarningSchema = z.strictObject({
+	code: z.literal("checkpoint_weak_payload"),
+	checkpoint: z.string(),
+	id: z.string(),
+	fields: z.array(z.enum(["recipient_role", "confirmation"]))
+});
+/**
+* A `high` risk checkpoint answered with the `locale` assurance only (no `presence` credential):
+* accepted, and shown as such.
+*/
+const LocaleOnHighRiskWarningSchema = z.strictObject({
+	code: z.literal("locale_on_high_risk"),
+	checkpoint: z.string(),
+	id: z.string()
+});
+z.strictObject({
+	code: z.literal("sensitive_unreadable"),
+	count: z.number().int().min(1)
+});
+/**
+* Warnings drawn from the journal alone, the same on every machine. Machine-local ones (a history
+* rewritten since this machine's last projection, sensitive content this machine cannot read)
+* are never written to `state.json`.
+*/
+const ProjectionWarningSchema = z.discriminatedUnion("code", [
+	ChainForkWarningSchema,
+	CheckpointIdCollisionWarningSchema,
+	CheckpointWeakPayloadWarningSchema,
+	LocaleOnHighRiskWarningSchema
+]);
+const ProjectedDeviceSchema = z.strictObject({
+	device: z.string(),
+	public_key: z.string()
+});
+/**
+* `state.json`: deterministic (two machines write the same bytes from the same journal, in
+* canonical JSON), `computed_at` being the date (`at`) of the last event applied in projection
+* order, never the clock.
+*/
+const ProjectionStateSchema = z.strictObject({
+	format: z.literal(1),
+	/** The journal position projected (a commit id in Git), or null for an empty journal. */
+	journal_head: z.string().nullable(),
+	/** The `at` of the last event applied, in projection order; null when none was applied. */
+	computed_at: z.string().nullable(),
+	/** The product id of the journal's `product.created`, or null. */
+	product: z.string().nullable(),
+	/** The registered machines, sorted by `device` (the creators are in `state.humans`). */
+	devices: z.array(ProjectedDeviceSchema),
+	/** Events applied. */
+	applied: z.number().int().min(0),
+	/** Events ignored, sorted by `id` then `reason`. */
+	ignored: z.array(IgnoredEventSchema),
+	warnings: z.array(ProjectionWarningSchema),
+	/** What the reducers built. */
+	state: z.record(z.string(), z.unknown())
+});
+//#endregion
+//#region ../../packages/protocol/dist/published-state.js
+/**
+* Where a view stands in a journal: `n` is the number of events the journal held (it never goes
+* down) and `heads` the head of each writer's chain.
+*/
+const FeedCursorSchema = z.strictObject({
+	n: z.number().int().min(0),
+	heads: z.record(z.string().min(1).max(64), z.string().min(1).max(128))
+});
+/** The devices the journal trusts, as the views need them. */
+const PublishedTrustedDeviceSchema = z.strictObject({
+	kind: z.enum([
+		"machine",
+		"human",
+		"phone",
+		"browser"
+	]),
+	sig_key: z.string().min(1).max(128),
+	enc_key: z.string().min(1).max(128).nullable(),
+	provisional: z.boolean()
+});
+/**
+* Where the import of an earlier history stands: the events brought in out of those the journal
+* holds, and the totals of the product (the creator reads « 48 stories, 131 validations »).
+* `ignored` counts the events the journal holds that were refused as forged, unsigned or cut from
+* their chain: they are told, never counted among the validations.
+*/
+const ImportInfoSchema = z.strictObject({
+	state: z.enum([
+		"none",
+		"running",
+		"done",
+		"failed"
+	]),
+	progress: z.strictObject({
+		events_done: z.number().int().nonnegative(),
+		events_total: z.number().int().nonnegative()
+	}).optional(),
+	stories: z.number().int().nonnegative().optional(),
+	validations: z.number().int().nonnegative().optional(),
+	ignored: z.number().int().nonnegative().optional(),
+	/** Why the import stopped (a short code, never a received value); with `failed` only. */
+	reason: z.string().max(100).optional()
+});
+/**
+* What the exit guard puts in place of a text it kept from leaving. A stable code, not a sentence:
+* a view recognises it and shows it in the creator's language.
+*/
+const REDACTED_SECRET = "redacted:secret";
+/**
+* What the main bridge publishes of a product. The projection is the one `get_state` returns; the
+* trust registry is the journal's (never the relay's list); the machines say which bridge is
+* main; the import says where the import of an earlier history stands.
+*/
+const PublishedStateSchema = z.strictObject({
+	projection: ProjectionStateSchema,
+	trust: z.strictObject({
+		/** True while the journal's root differs from the pinned one: no order is accepted. */
+		blocked: z.boolean(),
+		devices: z.record(z.string().regex(DEVICE_ID_PATTERN), PublishedTrustedDeviceSchema),
+		revoked: z.array(z.string().regex(DEVICE_ID_PATTERN))
+	}),
+	machines: z.strictObject({
+		primary: z.string().regex(BRIDGE_ID_PATTERN).nullable(),
+		/** True when nobody chose the main bridge: the engine elected it from the journal. */
+		automatic: z.boolean()
+	}),
+	import: ImportInfoSchema
+});
+readTolerant(z.strictObject({
+	current: z.enum(PHASE_IDS).nullable(),
+	since: z.string().nullable(),
+	phases: z.array(z.strictObject({
+		id: z.enum(PHASE_IDS),
+		status: z.enum([
+			"done",
+			"in_progress",
+			"in_review",
+			"upcoming",
+			"skipped"
+		])
+	})).max(PHASE_IDS.length)
+}));
+/**
+* What a story's file says, as the main bridge read it from the product's working copy (the
+* `story_docs` key of `projection.state` of the published state, set only for the files the
+* bridge could read and that follow the story contract): the title, the owner, the requirements
+* it covers, the stories it depends on, its branch and budget, its intent and its acceptance
+* criteria in order. The state's `state` record is open, so a view that does not know this key
+* still reads the rest; a view that does reads each entry with this schema and leaves out the
+* ones that do not fit.
+*/
+const PublishedStoryDocSchema = z.strictObject({
+	title: z.string().min(1).max(400),
+	owner: z.string().min(1).max(64).optional(),
+	epic: z.string().min(1).max(64).optional(),
+	requirements: z.array(z.string().min(1).max(64)).max(40),
+	depends_on: z.array(z.string().min(1).max(64)).max(40),
+	branch: z.string().min(1).max(400).optional(),
+	budget_usd: z.number().finite().nonnegative().optional(),
+	intent: z.string().max(1200),
+	criteria: z.array(z.string().max(400)).max(40)
+});
+readTolerant(PublishedStoryDocSchema);
+z.record(z.string().regex(/^[1-9]\d{0,5}-[1-9]\d{0,5}$/), PublishedStoryDocSchema);
+const PATH_SEGMENT_MAX = 200;
+const PATH_DEPTH_MAX = 16;
+const FEED_OPS_MAX = 2e4;
+/** One step of a change: set the value at a path, or remove it. */
+const FeedOpSchema = z.discriminatedUnion("op", [z.strictObject({
+	op: z.literal("set"),
+	path: z.array(z.string().max(PATH_SEGMENT_MAX)).min(1).max(PATH_DEPTH_MAX),
+	value: z.unknown()
+}), z.strictObject({
+	op: z.literal("remove"),
+	path: z.array(z.string().max(PATH_SEGMENT_MAX)).min(1).max(PATH_DEPTH_MAX)
+})]);
+const FeedSnapshotSchema = z.strictObject({
+	kind: z.literal("snapshot"),
+	schema: z.number().int().positive(),
+	product: z.string().regex(ULID_PATTERN),
+	cursor: FeedCursorSchema,
+	state: PublishedStateSchema
+});
+const FeedChangeSchema = z.strictObject({
+	kind: z.literal("change"),
+	schema: z.number().int().positive(),
+	product: z.string().regex(ULID_PATTERN),
+	from_cursor: FeedCursorSchema,
+	to_cursor: FeedCursorSchema,
+	ops: z.array(FeedOpSchema).max(FEED_OPS_MAX)
+});
+z.strictObject({
+	/** The same for all the parts of one message. */
+	id: z.string().regex(ULID_PATTERN),
+	index: z.number().int().min(0).max(4095),
+	count: z.number().int().min(1).max(4096),
+	/** SHA-256 of the whole content, base64url (43 characters). */
+	digest: z.string().length(43).refine(isCanonicalBase64url),
+	data: z.string().min(1).max(262144).refine(isCanonicalBase64url)
+});
+/** The bridge's presence: signed (as the message that carries it) and dated. */
+const FeedBeatSchema = z.strictObject({
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	/** Seconds since the epoch, on the bridge's clock. */
+	at: z.number().int().positive(),
+	bridge_version: SemverSchema,
+	protocol_version: z.number().int().positive(),
+	schema: z.number().int().positive(),
+	/** The last sequence number this bridge gave to a message for this view. */
+	last_seq: z.number().int().min(0),
+	/** The products this bridge publishes, and the cursor of each. */
+	publishes: z.array(z.strictObject({
+		product: z.string().regex(ULID_PATTERN),
+		cursor: FeedCursorSchema
+	})).max(64),
+	report: MachineReportSchema.optional()
+});
+z.strictObject({
+	schema: z.number().int().positive(),
+	product: z.string().regex(ULID_PATTERN),
+	cursor: FeedCursorSchema.nullable()
+});
+z.strictObject({
+	product: z.string().regex(ULID_PATTERN),
+	cursor: FeedCursorSchema
+});
+const FeedUpgradeRequiredSchema = z.strictObject({
+	current: z.number().int().positive(),
+	minimum: z.number().int().positive()
+});
+/**
+* What a bridge tells a device it just removed: the device it means, the product whose journal
+* holds the removal and the date. The device believes it only from the bridge it pinned when it was
+* linked (the message is signed by that bridge's key), never from the relay closing a connection.
+*/
+const FeedDeviceRemovedSchema = z.strictObject({
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	product: z.string().regex(ULID_PATTERN),
+	removed_at: z.iso.datetime()
+});
+readTolerant(PublishedStateSchema);
+readTolerant(FeedSnapshotSchema);
+readTolerant(FeedChangeSchema);
+readTolerant(FeedBeatSchema);
+readTolerant(FeedUpgradeRequiredSchema);
+readTolerant(FeedDeviceRemovedSchema);
+/** The most bytes one `vault_put` or `vault_blob` frame carries (decoded). */
+const VAULT_CHUNK_BYTES = 196608;
+/** What the relay keeps apart: a full vault, or the changes after it. */
+const VAULT_KINDS = ["full", "delta"];
+const b64 = (bytes) => z.string().length(Math.ceil(bytes * 4 / 3)).refine(isCanonicalBase64url);
+/** The content key sealed for one device: an ephemeral X25519 key, a nonce and the sealed key. */
+const VaultKeyBoxSchema = z.strictObject({
+	device: z.string().regex(DEVICE_ID_PATTERN),
+	/** The sender's ephemeral X25519 public key (32 bytes). */
+	eph: b64(32),
+	/** XChaCha20-Poly1305 nonce (24 bytes). */
+	nonce: b64(24),
+	/** The content key (32 bytes) and the authentication tag (16 bytes). */
+	box: b64(48)
+});
+z.strictObject({
+	v: z.literal(1),
+	product: z.string().regex(ULID_PATTERN),
+	kind: z.enum(VAULT_KINDS),
+	rev: z.number().int().positive(),
+	base_rev: z.number().int().positive().nullable(),
+	/** When the machine sealed the blob, ISO 8601. */
+	at: z.iso.datetime(),
+	/** The machine that sealed it, by its journal identifier. */
+	bridge: z.string().regex(BRIDGE_ID_PATTERN),
+	boxes: z.array(VaultKeyBoxSchema).max(64),
+	/** XChaCha20-Poly1305 nonce of the content (24 bytes). */
+	nonce: b64(24),
+	/** The compressed, encrypted content. */
+	body: z.string().min(1).refine(isCanonicalBase64url),
+	/** Signature of the header and of the digest of `body`. */
+	sig: z.string().length(86).refine(isCanonicalBase64url)
+});
+readTolerant(z.strictObject({
+	content: z.discriminatedUnion("kind", [FeedSnapshotSchema, FeedChangeSchema]),
+	report: MachineReportSchema.optional()
+}));
 //#endregion
 //#region ../../packages/protocol/dist/relay.js
 /**
@@ -8520,7 +10707,8 @@ const KEY_32 = z.string().length(43).refine(isCanonicalBase64url);
 */
 const RelayAttachDeclarationSchema = z.strictObject({
 	device_id: RelayIdSchema,
-	kind: z.literal("bridge"),
+	/** `bridge` for a machine attached during a rendezvous, `browser` for a browser registering itself. */
+	kind: z.enum(["bridge", "browser"]),
 	sig_key: KEY_32,
 	enc_key: KEY_32,
 	relay: z.string().min(1).max(253),
@@ -8607,15 +10795,83 @@ z.discriminatedUnion("type", [
 		/** Opaque bytes in base64url. */
 		data: z.string().min(1).max(base64urlLength(RENDEZVOUS_MAX_DATA_BYTES)).refine(isCanonicalBase64url)
 	}),
+	z.strictObject({
+		type: z.literal("device_register"),
+		declaration: RelayAttachDeclarationSchema,
+		signature: SignatureSchema,
+		credential: z.string().min(1).max(4096).optional()
+	}),
+	z.strictObject({
+		type: z.literal("device_revoke"),
+		sig_key: KEY_32.optional(),
+		/** Instead of the key: the relay's own identifier of the device (for a device no journal knows). */
+		device_id: RelayIdSchema.optional()
+	}).refine((frame) => frame.sig_key === void 0 !== (frame.device_id === void 0), { message: "name the device by its key or by its identifier, not both" }),
+	z.strictObject({
+		type: z.literal("vault_put"),
+		product: RelayIdSchema,
+		kind: z.enum(VAULT_KINDS),
+		/** Rises with every blob of the product. */
+		rev: z.number().int().positive(),
+		/** The revision a change follows; null for a full vault. */
+		base_rev: z.number().int().positive().nullable(),
+		index: z.number().int().min(0).max(255),
+		count: z.number().int().min(1).max(256),
+		data: z.string().min(1).max(base64urlLength(VAULT_CHUNK_BYTES)).refine(isCanonicalBase64url)
+	}),
+	z.strictObject({
+		type: z.literal("vault_get"),
+		product: RelayIdSchema
+	}),
+	z.strictObject({ type: z.literal("outbox_list") }),
+	z.strictObject({
+		type: z.literal("push_register"),
+		platform: z.enum(PUSH_PLATFORMS),
+		token: PushTokenSchema
+	}),
+	z.strictObject({ type: z.literal("push_unregister") }),
+	z.strictObject({
+		type: z.literal("notify"),
+		...PushNoticeSchema.shape
+	}),
+	z.strictObject({
+		type: z.literal("notify_clear"),
+		id: PushNoticeSchema.shape.id
+	}),
+	z.strictObject({
+		type: z.literal("presence_report"),
+		surface: z.enum(NOTIFY_SURFACES),
+		active: z.boolean()
+	}),
+	z.strictObject({ type: z.literal("notify_prefs_get") }),
+	z.strictObject({
+		type: z.literal("notify_prefs_set"),
+		prefs: NotifyPrefsSchema
+	}),
+	z.strictObject({
+		type: z.literal("outbox_cancel"),
+		id: RelayIdSchema
+	}),
 	z.strictObject({
 		type: z.literal("rv_attach"),
 		declaration: RelayAttachDeclarationSchema,
-		signature: SignatureSchema
+		signature: SignatureSchema,
+		/**
+		* A bridge already attached to the account that vouches for ANOTHER machine's declaration
+		* (the machine signed it itself): the identifier of the voucher on this relay.
+		*/
+		voucher: RelayIdSchema.optional()
 	})
 ]);
 const PresenceEntrySchema = z.strictObject({
 	device_id: RelayIdSchema,
 	kind: z.enum(RELAY_DEVICE_KINDS),
+	/**
+	* The public signing key of the device: a device of the account's journal is recognised by it (the
+	* relay's identifiers mean nothing to a journal), and a device no journal knows by its key is shown
+	* as not verified.
+	*/
+	sig_key: KEY_32.optional(),
 	online: z.boolean(),
 	/** ISO 8601, `null` when the device never connected. */
 	last_seen_at: z.string().nullable()
@@ -8667,37 +10923,104 @@ z.discriminatedUnion("type", [
 		prekey: PrekeySchema.nullable()
 	}),
 	z.strictObject({
-		type: z.literal("rv_opened"),
-		x: RendezvousIdSchema
+		type: z.literal("rv_opened"),
+		x: RendezvousIdSchema
+	}),
+	z.strictObject({
+		type: z.literal("rv_joined"),
+		x: RendezvousIdSchema,
+		peer: z.string().min(1).max(32),
+		open: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("rv_peer"),
+		peer: z.string().min(1).max(32)
+	}),
+	z.strictObject({
+		type: z.literal("rv_message"),
+		id: RelayIdSchema,
+		peer: z.string().min(1).max(32).optional(),
+		data: z.string().min(1).max(base64urlLength(RENDEZVOUS_MAX_DATA_BYTES)).refine(isCanonicalBase64url)
+	}),
+	z.strictObject({
+		type: z.literal("rv_sent"),
+		id: RelayIdSchema,
+		delivered: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("rv_attached"),
+		device_id: RelayIdSchema
+	}),
+	z.strictObject({
+		type: z.literal("device_registered"),
+		device_id: RelayIdSchema
+	}),
+	z.strictObject({
+		type: z.literal("device_revoked"),
+		found: z.boolean(),
+		/** The relay's identifier of the device it stopped serving; null when there was none. */
+		device_id: RelayIdSchema.nullable()
+	}),
+	z.strictObject({
+		type: z.literal("device_gone"),
+		device_id: RelayIdSchema
+	}),
+	z.strictObject({
+		type: z.literal("vault_stored"),
+		product: RelayIdSchema,
+		rev: z.number().int().positive()
+	}),
+	z.strictObject({
+		type: z.literal("vault_blob"),
+		product: RelayIdSchema,
+		rev: z.number().int().positive(),
+		base_rev: z.number().int().positive().nullable(),
+		kind: z.enum(VAULT_KINDS),
+		/** When the relay received it, ISO 8601. */
+		stored_at: z.iso.datetime(),
+		index: z.number().int().min(0).max(255),
+		count: z.number().int().min(1).max(256),
+		data: z.string().min(1).max(base64urlLength(VAULT_CHUNK_BYTES)).refine(isCanonicalBase64url)
+	}),
+	z.strictObject({
+		type: z.literal("vault_end"),
+		product: RelayIdSchema,
+		blobs: z.number().int().min(0)
 	}),
+	z.strictObject({ type: z.literal("vault_cleared") }),
+	z.strictObject({ type: z.literal("push_registered") }),
+	z.strictObject({ type: z.literal("push_unregistered") }),
 	z.strictObject({
-		type: z.literal("rv_joined"),
-		x: RendezvousIdSchema,
-		peer: z.string().min(1).max(32),
-		open: z.boolean()
+		type: z.literal("notified"),
+		id: PushNoticeSchema.shape.id,
+		sent: z.number().int().min(0).max(1e3)
 	}),
 	z.strictObject({
-		type: z.literal("rv_peer"),
-		peer: z.string().min(1).max(32)
+		type: z.literal("notify_prefs"),
+		prefs: NotifyPrefsSchema
 	}),
 	z.strictObject({
-		type: z.literal("rv_message"),
-		id: RelayIdSchema,
-		peer: z.string().min(1).max(32).optional(),
-		data: z.string().min(1).max(base64urlLength(RENDEZVOUS_MAX_DATA_BYTES)).refine(isCanonicalBase64url)
+		type: z.literal("notice"),
+		...PushNoticeSchema.shape
 	}),
 	z.strictObject({
-		type: z.literal("rv_sent"),
-		id: RelayIdSchema,
-		delivered: z.boolean()
+		type: z.literal("outbox"),
+		items: z.array(z.strictObject({
+			id: RelayIdSchema,
+			to: RelayIdSchema,
+			queued_at: z.iso.datetime(),
+			expires_at: z.iso.datetime()
+		})).max(500)
 	}),
 	z.strictObject({
-		type: z.literal("rv_attached"),
-		device_id: RelayIdSchema
+		type: z.literal("outbox_cancelled"),
+		id: RelayIdSchema,
+		cancelled: z.boolean()
 	})
 ]);
 //#endregion
 //#region ../../packages/protocol/dist/pairing.js
+const PRODUCT_ID = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
 /**
 * The messages of the pairing link. Generic on purpose
 *: schemas and codes only; the link's bytes and the boxes are in `packages/crypto`, the
@@ -8709,6 +11032,10 @@ z.discriminatedUnion("type", [
 * - `envelope` (bridge to browser): a message from peer to peer encrypted for the
 *   browser's key and signed by the bridge: `link.welcome` then one `product.keys` per product;
 * - `refused` (bridge to browser): a code and nothing else; informative, not authenticated.
+*
+* A machine that joins with a short code does not hold a link's secret: both sides run a password
+* exchange first (`pake_*` messages), and the box key is drawn from the session key it gives. The
+* bridge then says who it is in `hello`; the machine answers with its `request`.
 */
 /** Codes of the pairing, said by the bridge (separate from `ErrorCode`, like the relay's). */
 const PAIR_ERROR_CODES = {
@@ -8716,22 +11043,50 @@ const PAIR_ERROR_CODES = {
 	PAIRING_EXPIRED: "PAIRING_EXPIRED",
 	PAIRING_INVALID_PROOF: "PAIRING_INVALID_PROOF",
 	PAIRING_KEY_MISMATCH: "PAIRING_KEY_MISMATCH",
+	/** A machine joined from a folder whose product the bridge that gave the code does not serve. */
+	PAIRING_PRODUCT_UNKNOWN: "PAIRING_PRODUCT_UNKNOWN",
 	PAIRING_WRONG_ACCOUNT: "PAIRING_WRONG_ACCOUNT"
 };
 /** The type labels of the messages (`t` of the signed ones, `type` of the boxes and messages). */
 const PAIR_MESSAGE_TYPES = {
 	request: "link.request/v1",
 	welcome: TRUST_SIGNATURE_TAGS.linkWelcome,
-	productKeys: "product.keys/v1"
+	productKeys: "product.keys/v1",
+	hello: "pair.hello/v1"
 };
 const key32 = z.string().length(43).refine(isCanonicalBase64url);
+const key22 = z.string().length(22).refine(isCanonicalBase64url);
 const label = z.string().min(1).max(40);
+/** The devices that answer a pairing: a browser, a phone or another machine. */
+const REQUESTER_DEVICE_ID_PATTERN = /^(?:browser|phone|machine):[A-Za-z0-9_-]{16}$/;
+const PairCodeIdSchema = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{8}$/);
+const PairCodeSecretSchema = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{6}$/);
+/** `pair.offer/v1` for a link or a QR: a linked device asks its bridge to open a rendezvous. */
+const PairLinkOfferOrderSchema = z.strictObject({
+	t: z.literal(TRUST_SIGNATURE_TAGS.pairOffer),
+	/** Which kind of device the link is for: another browser or a phone. */
+	kind: z.enum(["link", "phone"]),
+	/** The rendezvous identifier: 16 random bytes in base64url. */
+	x: z.string().length(22).refine(isCanonicalBase64url),
+	/** The link's secret: 16 random bytes in base64url. Travels inside the encrypted order only. */
+	s: z.string().length(22).refine(isCanonicalBase64url)
+});
+/** `pair.offer/v1` for another machine: the short code, drawn by the linked device. */
+const PairCodeOfferOrderSchema = z.strictObject({
+	t: z.literal(TRUST_SIGNATURE_TAGS.pairOffer),
+	kind: z.literal("machine"),
+	/** The address to meet at (8 symbols). */
+	x: PairCodeIdSchema,
+	/** The password (6 symbols). Travels inside the encrypted order only. */
+	w: PairCodeSecretSchema
+});
+z.union([PairLinkOfferOrderSchema, PairCodeOfferOrderSchema]);
 z.strictObject({
 	t: z.literal(PAIR_MESSAGE_TYPES.request),
 	/** The account of the requester, as the relay knows it. */
 	account: RelayIdSchema,
 	browser: z.strictObject({
-		device: z.string().regex(/^browser:[A-Za-z0-9_-]{16}$/),
+		device: z.string().regex(REQUESTER_DEVICE_ID_PATTERN),
 		sig: DeviceSigKeySchema,
 		enc: DeviceEncKeySchema
 	}),
@@ -8739,7 +11094,29 @@ z.strictObject({
 	declared: z.strictObject({
 		type: label,
 		os: label
-	})
+	}),
+	/**
+	* The requester's signature recognising the creator's key as the root of the link (the root
+	* the link carried): it ties that key to the account without any gesture. Optional: a requester
+	* that does not sign it is linked all the same, only the key stays unattached.
+	*/
+	root_certification: z.strictObject({
+		issued_at: z.iso.datetime(),
+		sig: Ed25519SignatureSchema
+	}).optional(),
+	/**
+	* Only a machine joining with a short code: the product it serves and the declaration it
+	* signed to be attached to the relay (the bridge that holds the rendezvous vouches for it).
+	*/
+	machine: z.strictObject({
+		product: z.string().regex(PRODUCT_ID),
+		relay_device: RelayIdSchema,
+		attach_expires_at: z.number().int().positive(),
+		attach_sig: Ed25519SignatureSchema
+	}).optional()
+}).refine((request) => request.browser.device.startsWith("machine:") === (request.machine !== void 0), {
+	path: ["machine"],
+	message: "a machine says what it serves, and only a machine does"
 });
 z.strictObject({
 	t: z.literal(PAIR_MESSAGE_TYPES.welcome),
@@ -8753,9 +11130,11 @@ z.strictObject({
 		enc: z.strictObject({
 			alg: z.literal(DEVICE_ENC_ALG),
 			key: key32
-		})
+		}),
+		/** The identifier the relay knows the bridge by: where the browser's messages to it go. */
+		relay_device: z.string().regex(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/).optional()
 	}),
-	browser: z.string().regex(/^browser:[A-Za-z0-9_-]{16}$/),
+	browser: z.string().regex(REQUESTER_DEVICE_ID_PATTERN),
 	/** SHA-256 of the opened request, base64url. */
 	request: key32,
 	registry: z.array(z.strictObject({
@@ -8769,12 +11148,38 @@ z.strictObject({
 	})).max(64),
 	sig: Ed25519SignatureSchema
 });
+z.strictObject({
+	t: z.literal(PAIR_MESSAGE_TYPES.hello),
+	root: z.strictObject({
+		device: z.string().regex(/^(machine|human):[A-Za-z0-9_-]{16}$/),
+		key: key32
+	}),
+	bridge: z.strictObject({
+		device: z.string().regex(/^machine:[A-Za-z0-9_-]{16}$/),
+		sig: DeviceSigKeySchema,
+		enc: z.strictObject({
+			alg: z.literal(DEVICE_ENC_ALG),
+			key: key32
+		})
+	}),
+	/** The account of the bridge, which the machine joins. */
+	account: RelayIdSchema,
+	now: z.number().int().positive()
+});
 z.strictObject({
 	t: z.literal(PAIR_MESSAGE_TYPES.productKeys),
-	product: z.string().regex(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/),
+	product: z.string().regex(PRODUCT_ID),
 	/** The identifier of the key (`apkeyid1`): the browser checks it against the journal's events. */
 	key_id: z.string().min(1).max(64),
-	key: key32
+	key: key32,
+	/**
+	* The keys the product had before it was renewed, so that a device linked afterwards reads the
+	* whole history. Each is checked against its own `key_id` by the receiver.
+	*/
+	older: z.array(z.strictObject({
+		key_id: z.string().min(1).max(64),
+		key: key32
+	})).max(32).optional()
 });
 z.discriminatedUnion("k", [
 	z.strictObject({
@@ -8793,111 +11198,529 @@ z.discriminatedUnion("k", [
 			ciphertext: z.string().min(1).max(65536)
 		})
 	}),
+	z.strictObject({
+		k: z.literal("pake_init"),
+		nonce: key22,
+		share: key32
+	}),
+	z.strictObject({
+		k: z.literal("pake_reply"),
+		share: key32
+	}),
+	z.strictObject({
+		k: z.literal("pake_confirm"),
+		mac: key32
+	}),
+	z.strictObject({
+		k: z.literal("pake_confirm_b"),
+		mac: key32
+	}),
+	z.strictObject({
+		k: z.literal("hello"),
+		nonce: z.string().min(1).max(64),
+		ciphertext: z.string().min(1).max(65536)
+	}),
 	z.strictObject({
 		k: z.literal("refused"),
 		code: z.enum(Object.values(PAIR_ERROR_CODES))
 	})
 ]);
-/** The local reference holding the last journal commit projected: never pushed. */
-const JOURNAL_PROJECTED_REF = "refs/agentplugged/projected";
-const IgnoredEventSchema = z.strictObject({
-	id: z.string(),
-	reason: z.enum([
-		"unknown_signer",
-		"bad_signature",
-		"broken_chain",
-		"wrong_product",
-		"invalid",
-		"key_conflict",
-		"product_conflict",
-		"test_type",
-		"checkpoint_id_collision",
-		"not_human",
-		"already_resolved",
-		"unendorsed_human",
-		"checkpoint_unknown",
-		"decrypt_failed",
-		"key_proof_invalid",
-		"sensitive_in_clear",
-		"unexpected_encryption",
-		"unsupported_alg",
-		"untrusted_authorization",
-		"device_revoked",
-		"dismissed",
-		"not_reopenable"
-	])
+//#endregion
+//#region ../../packages/protocol/dist/product-browse.js
+/**
+* Choosing where a product is made, by clicking: the shapes the request and the answer of the file
+* reading carry (`folders`). A device names a place the machine listed in its report and the steps
+* taken inside it, one folder name each, as the machine listed them; it never sends a path. The
+* machine resolves the steps itself, refuses whatever leaves the place (a link, a junction, a
+* separator, `..`), and lists only the folders a creator may put a product in: no hidden folder,
+* no folder of the system.
+*/
+/** The request shape (without the identifier, the version and the product, which the file reading adds). */
+const FoldersRequestFields = {
+	op: z.literal("folders"),
+	/** The identifier of a place the machine listed. */
+	location: z.string().regex(PRODUCT_LOCATION_ID_PATTERN),
+	/** The folders gone into, from the place. */
+	path: z.array(z.string().refine(isBrowseStep, { message: "a folder name, not a path" })).max(12).optional()
+};
+const FoldersDataSchema = z.strictObject({
+	op: z.literal("folders"),
+	location: z.string().regex(PRODUCT_LOCATION_ID_PATTERN),
+	/** The steps the answer is about (the request's). */
+	path: z.array(z.string().refine(isBrowseStep)).max(12),
+	/** The folder as the creator reads it (the home folder written `~`). */
+	label: z.string().min(1).max(1200),
+	/** The folders inside it that can be gone into, by name. */
+	folders: z.array(z.string().refine(isBrowseStep)).max(200),
+	/** True when there are more folders than listed. */
+	truncated: z.boolean()
 });
-/** Two valid events of one device name the same `prev` (two clones on one machine): both kept. */
-const ChainForkWarningSchema = z.strictObject({
-	code: z.literal("chain_fork"),
-	device: z.string(),
-	prev: z.string().nullable(),
-	ids: z.array(z.string())
+//#endregion
+//#region ../../packages/protocol/dist/voice-read.js
+/** The largest piece of audio of one request, in bytes of PCM (3 seconds); the envelope must hold it sealed. */
+const TRANSCRIBE_CHUNK_MAX_BYTES = 96e3;
+/** The longest text the machine gives back, in characters. */
+const TRANSCRIBE_TEXT_MAX_CHARS = 4e3;
+/** What the request carries on top of the file reading's own fields. */
+const TranscribeRequestFields = {
+	op: z.literal("transcribe"),
+	/**
+	* `probe`: asks whether the machine can transcribe, with no audio. `audio`: one piece of a
+	* phrase; the last one (`final`) makes the machine transcribe and answer with the text.
+	*/
+	step: z.enum(["probe", "audio"]),
+	/** The phrase the piece belongs to (audio only). */
+	session: z.string().regex(ULID_PATTERN).optional(),
+	/** The place of the piece in the phrase, from 0 (audio only). */
+	seq: z.int().min(0).max(7).optional(),
+	/** True on the last piece of the phrase (audio only). */
+	final: z.boolean().optional(),
+	/** The language to recognize, a BCP-47 tag (audio only). */
+	language: z.string().regex(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})?$/).optional(),
+	/** The PCM of the piece, base64url (audio only). */
+	audio: z.string().regex(/^[A-Za-z0-9_-]*$/).max(base64urlLength(TRANSCRIBE_CHUNK_MAX_BYTES)).optional()
+};
+const TranscribeDataSchema = z.strictObject({
+	op: z.literal("transcribe"),
+	/** True when the machine has a transcription command set up. */
+	ready: z.boolean(),
+	/** The words understood: only on the answer to the last piece of a phrase. */
+	text: z.string().max(TRANSCRIBE_TEXT_MAX_CHARS).optional()
 });
+/** The longest path, in characters, and the longest one name of a branch. */
+const FILES_PATH_MAX = 1024;
 /**
-* Two `checkpoint.opened` events give the same checkpoint id: `ids[0]` opened it, the others are
-* ignored (`checkpoint_id_collision`).
+* Where a file is read: the working copy of the product as it is now (uncommitted work included),
+* a branch or a commit of its repository, or the working copy of the story that works on a branch.
 */
-const CheckpointIdCollisionWarningSchema = z.strictObject({
-	code: z.literal("checkpoint_id_collision"),
-	checkpoint: z.string(),
-	ids: z.array(z.string())
+const FilesRefSchema = z.discriminatedUnion("kind", [
+	z.strictObject({ kind: z.literal("worktree") }),
+	z.strictObject({
+		kind: z.literal("branch"),
+		name: z.string().min(1).max(200)
+	}),
+	z.strictObject({
+		kind: z.literal("commit"),
+		sha: z.string().regex(/^[0-9a-f]{40,64}$/)
+	}),
+	z.strictObject({
+		kind: z.literal("workspace"),
+		branch: z.string().min(1).max(200)
+	})
+]);
+const RequestBase = {
+	v: z.literal(1),
+	/** Chosen by the asking device: the answer repeats it. */
+	id: z.string().regex(ULID_PATTERN),
+	product: z.string().regex(ULID_PATTERN)
+};
+z.discriminatedUnion("op", [
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("tree"),
+		ref: FilesRefSchema,
+		path: z.string().max(FILES_PATH_MAX)
+	}),
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("file"),
+		ref: FilesRefSchema,
+		path: z.string().min(1).max(FILES_PATH_MAX)
+	}),
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("download"),
+		ref: FilesRefSchema,
+		path: z.string().min(1).max(FILES_PATH_MAX)
+	}),
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("refs")
+	}),
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("changes"),
+		base: FilesRefSchema,
+		head: FilesRefSchema
+	}),
+	z.strictObject({
+		...RequestBase,
+		op: z.literal("live"),
+		after: z.number().int().min(0).optional(),
+		epoch: z.string().min(1).max(64).optional()
+	}),
+	z.strictObject({
+		...RequestBase,
+		...CodePullsRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...CodePullRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...CodeDiffRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...CodeEditorRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...DocsListRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...DocsTraceRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...DocsRetrosRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...KbListRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...KbAskRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...CostsRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...BriefingRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...TranscribeRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...FindRequestFields
+	}),
+	z.strictObject({
+		...RequestBase,
+		...FoldersRequestFields
+	})
+]);
+/** Why a request was not answered with data; stable codes the views translate. */
+const FilesErrorCodeSchema = z.enum([
+	"NOT_FOUND",
+	"OUTSIDE_PRODUCT",
+	"PROTECTED",
+	"TOO_LARGE",
+	"WRONG_KIND",
+	"BAD_REQUEST",
+	"UNAVAILABLE",
+	"BUSY",
+	...CODE_ERROR_CODES
+]);
+const FilesEntrySchema = z.strictObject({
+	name: z.string().min(1).max(255),
+	kind: z.enum([
+		"file",
+		"dir",
+		"link"
+	]),
+	/** Bytes; absent for a folder. */
+	size: z.number().int().min(0).optional(),
+	/** True for a file the bridge never sends (secrets): the name is visible, the content is not. */
+	protected: z.literal(true).optional()
+});
+const FilesBranchSchema = z.strictObject({
+	name: z.string().min(1).max(200),
+	sha: z.string().regex(/^[0-9a-f]{40,64}$/),
+	/** True for the branch the product's folder is on now. */
+	current: z.literal(true).optional(),
+	/** True when a working copy of this branch exists on the machine (a story at work). */
+	workspace: z.literal(true).optional()
+});
+const FilesChangeSchema = z.strictObject({
+	status: z.enum([
+		"added",
+		"modified",
+		"deleted",
+		"renamed"
+	]),
+	path: z.string().min(1).max(FILES_PATH_MAX),
+	/** The old path of a renamed file. */
+	from: z.string().min(1).max(FILES_PATH_MAX).optional(),
+	protected: z.literal(true).optional()
 });
 /**
-* A signed `checkpoint.opened` asks a weaker recipient or confirmation than the rules give: the
-* projection applies the rules' values, and says so. `fields` names what was raised.
-*/
-const CheckpointWeakPayloadWarningSchema = z.strictObject({
-	code: z.literal("checkpoint_weak_payload"),
-	checkpoint: z.string(),
-	id: z.string(),
-	fields: z.array(z.enum(["recipient_role", "confirmation"]))
+* One line of what an agent does. `kind` is a stable code; `text` is plain text the view never
+* interprets: what the agent said (`say`), the name of a tool it called (`tool`, `tool_ok`,
+* `tool_failed`, `denied`) or the outcome code of the run (`end`).
+*
+* Three kinds tell what a call does to the machine: `read` and `edit` carry the path of the file,
+* relative to the agent's working folder, and `command` carries the command; a command's issue
+* (`command_ok`, `command_failed`) has no text and points to its command by `of`. A path that
+* leaves the working folder is never told: the line has `outside` and no text. `protected` marks
+* a file whose content the bridge never shows. `link` says where to read what an `edit` changed:
+* the same references and paths as the file reading (`file`, `changes`). The results of a tool,
+* and the content of files, are never in a line.
+*
+* In a conversation with Noah two more kinds appear: `creator`, the creator's own message (plain
+* text, so that their other devices see it), and `routed`, what the bridge did with a handover
+* Noah recorded, as a stable code (`noah:started?agent=iris`) the view tells in the creator's
+* language. What Noah says is a `say` of the agent `noah`: untrusted text, like any agent's.
+*/
+const LiveLineSchema = z.strictObject({
+	seq: z.number().int().min(1),
+	/** Milliseconds since the epoch, on the bridge's clock. */
+	at: z.number().int().min(0),
+	agent: z.string().min(1).max(64),
+	kind: z.enum([
+		"start",
+		"say",
+		"tool",
+		"tool_ok",
+		"tool_failed",
+		"denied",
+		"end",
+		"read",
+		"edit",
+		"command",
+		"command_ok",
+		"command_failed",
+		"creator",
+		"routed"
+	]),
+	text: z.string().max(2e3).optional(),
+	/** For a command's issue: the `seq` of the line of the command. */
+	of: z.number().int().min(1).optional(),
+	/** The path leaves the agent's working folder: it is not told. */
+	outside: z.literal(true).optional(),
+	/** The file is a secret's: its name is told, its content is never shown. */
+	protected: z.literal(true).optional(),
+	/** The line comes from a session the creator opened in the tool's own terminal. */
+	terminal: z.literal(true).optional(),
+	/** For a change: where its content and its difference can be read. */
+	link: z.strictObject({
+		ref: FilesRefSchema,
+		path: z.string().min(1).max(FILES_PATH_MAX)
+	}).optional()
 });
 /**
-* A `high` risk checkpoint answered with the `locale` assurance only (no `presence` credential):
-* accepted, and shown as such.
+* Whether the sessions the creator opens in a tool's own terminal can be followed: `listening`
+* (the tool's hook is in the repository), `hook_missing` (it is not: `sync` writes it),
+* `unsupported` (the tool has no such hook yet). A stable code the views tell in the creator's language.
 */
-const LocaleOnHighRiskWarningSchema = z.strictObject({
-	code: z.literal("locale_on_high_risk"),
-	checkpoint: z.string(),
-	id: z.string()
-});
-z.strictObject({
-	code: z.literal("sensitive_unreadable"),
-	count: z.number().int().min(1)
-});
+const LiveTerminalStateSchema = z.enum([
+	"listening",
+	"hook_missing",
+	"unsupported"
+]);
+/** Where the chain of the product stands, as a code the views tell in the creator's language. */
+const LiveChainStateSchema = z.enum([
+	"none",
+	"running",
+	"waiting",
+	"paused",
+	"handed_over",
+	"conversation",
+	"stopped"
+]);
+/** What an answer carries, by operation. */
+const FilesDataSchema = z.discriminatedUnion("op", [
+	CodePullsDataSchema,
+	CodePullDataSchema,
+	CodeDiffDataSchema,
+	CodeEditorDataSchema,
+	DocsListDataSchema,
+	DocsTraceDataSchema,
+	DocsRetrosDataSchema,
+	KbListDataSchema,
+	KbAskDataSchema,
+	FindDataSchema,
+	CostsDataSchema,
+	BriefingDataSchema,
+	TranscribeDataSchema,
+	FoldersDataSchema,
+	z.strictObject({
+		op: z.literal("tree"),
+		path: z.string().max(FILES_PATH_MAX),
+		entries: z.array(FilesEntrySchema).max(5e3),
+		/** True when the folder holds more than the bridge lists. */
+		truncated: z.boolean()
+	}),
+	z.strictObject({
+		op: z.literal("file"),
+		path: z.string().min(1).max(FILES_PATH_MAX),
+		size: z.number().int().min(0),
+		/** `text`: shown; `binary`: only offered for download. */
+		content: z.enum(["text", "binary"]),
+		/** True when the file can be asked for as bytes to save (it is not larger than the bridge sends). */
+		downloadable: z.boolean(),
+		/** The text, with each line that looked like a secret replaced by `redacted:secret`. */
+		text: z.string().optional(),
+		/** How many lines were replaced. */
+		masked: z.number().int().min(0)
+	}),
+	z.strictObject({
+		op: z.literal("download"),
+		path: z.string().min(1).max(FILES_PATH_MAX),
+		size: z.number().int().min(0),
+		/** The bytes, base64url. */
+		bytes: z.string()
+	}),
+	z.strictObject({
+		op: z.literal("refs"),
+		branches: z.array(FilesBranchSchema).max(500),
+		truncated: z.boolean()
+	}),
+	z.strictObject({
+		op: z.literal("changes"),
+		files: z.array(FilesChangeSchema).max(5e3),
+		truncated: z.boolean()
+	}),
+	z.strictObject({
+		op: z.literal("live"),
+		/** Tells one run of the bridge's memory from another: send it back with `next`. */
+		epoch: z.string().min(1).max(64),
+		/** True when the cursor asked with was not this bridge's: the lines start again from the oldest kept. */
+		reset: z.boolean(),
+		/** How many lines were lost between the cursor and the first line below (memory is bounded). */
+		dropped: z.number().int().min(0),
+		/** The cursor to ask with next time. */
+		next: z.number().int().min(0),
+		/** True when more lines wait: ask again at once. */
+		more: z.boolean(),
+		chain: LiveChainStateSchema,
+		/** The agent that works now, or null. */
+		working: z.strictObject({
+			agent: z.string().min(1).max(64),
+			story: z.string().min(1).max(32).optional(),
+			tool: z.string().min(1).max(32)
+		}).nullable(),
+		lines: z.array(LiveLineSchema).max(100),
+		/** For each tool, whether its sessions opened in the creator's own terminal can be followed. */
+		terminal: z.array(z.strictObject({
+			tool: z.enum([
+				"claude-code",
+				"codex",
+				"antigravity",
+				"cursor"
+			]),
+			state: LiveTerminalStateSchema
+		})).max(8).optional(),
+		/** Present while the creator holds the session: where to go and what to type in the terminal. */
+		handover: z.strictObject({
+			tool: z.string().min(1).max(32),
+			cwd: z.string().min(1).max(FILES_PATH_MAX),
+			command: z.string().min(1).max(300)
+		}).optional()
+	})
+]);
+const FilesResponseSchema = z.discriminatedUnion("ok", [z.strictObject({
+	v: z.literal(1),
+	id: z.string().regex(ULID_PATTERN),
+	product: z.string().regex(ULID_PATTERN),
+	ok: z.literal(true),
+	/** The commit the answer was read at, or `worktree` for the working copy. */
+	at: z.string().max(80),
+	/** Milliseconds since the epoch, on the bridge's clock: when it was read. */
+	read_at: z.number().int().min(0),
+	data: FilesDataSchema
+}), z.strictObject({
+	v: z.literal(1),
+	id: z.string().regex(ULID_PATTERN),
+	product: z.string().regex(ULID_PATTERN),
+	ok: z.literal(false),
+	code: FilesErrorCodeSchema,
+	/** For the platform codes: the host of the repository, so that the device can name it. */
+	host: ForgeHostSchema.optional(),
+	/** For `TOO_LARGE`: the size of the file and what the bridge shows at most. */
+	size: z.number().int().min(0).optional(),
+	max: z.number().int().min(0).optional()
+})]);
+readTolerant(FilesDataSchema);
+readTolerant(FilesResponseSchema);
+//#endregion
+//#region ../../packages/protocol/dist/share.js
 /**
-* Warnings drawn from the journal alone, the same on every machine. Machine-local ones (a history
-* rewritten since this machine's last projection, sensitive content this machine cannot read)
-* are never written to `state.json`.
+* The read-only progress page: a page a creator shares without any account. The device builds it
+* from a short allow-list (never a copy of the state), seals it with a key made for this one link,
+* and hands the relay the sealed bytes only. The key travels in the fragment of the link, which no
+* browser sends to a server, so the relay can neither read the page nor give it to anyone who does
+* not hold the whole link. The relay erases the page at its expiry or when the creator withdraws
+* the link.
 */
-const ProjectionWarningSchema = z.discriminatedUnion("code", [
-	ChainForkWarningSchema,
-	CheckpointIdCollisionWarningSchema,
-	CheckpointWeakPayloadWarningSchema,
-	LocaleOnHighRiskWarningSchema
-]);
-const ProjectedDeviceSchema = z.strictObject({
-	device: z.string(),
-	public_key: z.string()
+/**
+* The stages and the phases a page can name. Written here, not imported, so that the page that
+* reads a link stays light (a test compares them with the lists of the product and of the method).
+*/
+const SHARE_STAGES = [
+	"framing",
+	"development",
+	"launch",
+	"online"
+];
+const SHARE_PHASES = [
+	"framing",
+	"planning",
+	"design",
+	"build",
+	"delivery",
+	"launch"
+];
+/** The largest sealed page, in bytes. */
+const SHARE_MAX_SEALED_BYTES = 65536;
+/** The identifier of a link: 16 random bytes, in base64url (22 characters). */
+const SHARE_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+const sealedText = (maxBytes) => z.string().min(1).max(Math.ceil(maxBytes * 4 / 3)).refine(isCanonicalBase64url);
+z.strictObject({
+	product: z.string().regex(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/),
+	/** 12 bytes. */
+	nonce: z.string().length(16).refine(isCanonicalBase64url),
+	ciphertext: sealedText(SHARE_MAX_SEALED_BYTES)
 });
+z.strictObject({ id: z.string().regex(SHARE_ID_PATTERN) });
 z.strictObject({
-	format: z.literal(1),
-	/** The journal position projected (a commit id in Git), or null for an empty journal. */
-	journal_head: z.string().nullable(),
-	/** The `at` of the last event applied, in projection order; null when none was applied. */
-	computed_at: z.string().nullable(),
-	/** The product id of the journal's `product.created`, or null. */
-	product: z.string().nullable(),
-	/** The registered machines, sorted by `device` (the creators are in `state.humans`). */
-	devices: z.array(ProjectedDeviceSchema),
-	/** Events applied. */
-	applied: z.number().int().min(0),
-	/** Events ignored, sorted by `id` then `reason`. */
-	ignored: z.array(IgnoredEventSchema),
-	warnings: z.array(ProjectionWarningSchema),
-	/** What the reducers built. */
-	state: z.record(z.string(), z.unknown())
+	v: z.literal(1),
+	/** When the page was made, in milliseconds since the epoch. */
+	made_at: z.number().int().nonnegative(),
+	product: z.strictObject({
+		name: z.string().min(1).max(80),
+		stage: z.enum(SHARE_STAGES)
+	}),
+	phases: z.array(z.strictObject({
+		id: z.enum(SHARE_PHASES),
+		state: z.enum([
+			"done",
+			"current",
+			"review",
+			"upcoming"
+		])
+	})).max(SHARE_PHASES.length),
+	sprint: z.strictObject({
+		goal: z.string().min(1).max(160).nullable(),
+		done: z.number().int().nonnegative(),
+		total: z.number().int().nonnegative()
+	}).nullable(),
+	/** Stories merged, all sprints together. */
+	delivered: z.number().int().nonnegative(),
+	stories: z.array(z.strictObject({
+		id: z.string().regex(/^[A-Za-z0-9.-]{1,16}$/),
+		/** `null` when the title was held back or the story has none. */
+		title: z.string().min(1).max(120).nullable(),
+		state: z.enum([
+			"todo",
+			"development",
+			"review",
+			"done"
+		]),
+		/** Steps (acceptance criteria) proven out of those the story lists; `null` when none is listed. */
+		steps: z.strictObject({
+			done: z.number().int().nonnegative(),
+			total: z.number().int().nonnegative()
+		}).nullable()
+	})).max(60),
+	/** Stories of the sprint past the limit, counted and not listed. */
+	more: z.number().int().nonnegative()
 });
 /** A page of checkpoints, newest first: filtered by status, type or story, before an id. */
 const StateCheckpointsInputSchema = z.strictObject({
@@ -8985,6 +11808,87 @@ const CursorCliConfigSchema = z.looseObject({ permissions: z.looseObject({
 	allow: z.array(z.string()).optional(),
 	deny: z.array(z.string()).optional()
 }).optional() });
+/** The CSV export's columns: those of `HistoryEntry`, then the reason of an ignored answer. */
+const HISTORY_CSV_COLUMNS = [...[
+	"at",
+	"author",
+	"author_trust",
+	"author_endorsed_at",
+	"source",
+	"decision",
+	"option",
+	"waiver_until",
+	"assurance",
+	"locale_on_high_risk",
+	"checkpoint",
+	"checkpoint_type",
+	"checkpoint_risk",
+	"checkpoint_title",
+	"story",
+	"event",
+	"checkpoint_phase",
+	"quote",
+	"relayed_by",
+	"channel",
+	"stack",
+	"via"
+], "ignored_reason"];
+/** The UTF-8 byte order mark: spreadsheets then read the accents right. */
+const BOM = String.fromCharCode(65279);
+/** Starts a spreadsheet formula when a cell begins with it. */
+const FORMULA_START = /^[=+\-@\t\r]/;
+/**
+* One CSV field (RFC 4180): quoted when it holds a comma, a quote or a line break. A text a
+* spreadsheet would run as a formula (`=`, `+`, `-`, `@`, tab, CR first) is prefixed with `'`.
+*/
+function csvField(value) {
+	let text = value === null ? "" : String(value);
+	if (FORMULA_START.test(text)) text = `'${text}`;
+	return /[",\r\n]/.test(text) ? `"${text.replaceAll("\"", "\"\"")}"` : text;
+}
+function ignoredRow(item) {
+	return {
+		at: item.at,
+		author: item.author,
+		author_trust: null,
+		author_endorsed_at: null,
+		source: null,
+		decision: item.decision,
+		option: null,
+		waiver_until: null,
+		assurance: null,
+		locale_on_high_risk: null,
+		checkpoint: item.checkpoint,
+		checkpoint_type: null,
+		checkpoint_risk: null,
+		checkpoint_title: null,
+		story: item.story,
+		checkpoint_phase: null,
+		quote: null,
+		relayed_by: null,
+		channel: null,
+		stack: null,
+		via: null,
+		event: item.event,
+		ignored_reason: item.reason
+	};
+}
+/**
+* The CSV export, for spreadsheets (RFC 4180, UTF-8 with a byte order mark so that accents read
+* right): a header of the English field names, then one record per entry, then (`--all`) one per
+* ignored answer with its `ignored_reason` (empty for the valid ones). Each line ends with CRLF; a
+* null is an empty field; formulas are neutralised (`csvField`), so the JSON export is the exact
+* one.
+*/
+function historyCsv(entries, ignored = null) {
+	const rows = [...entries.map((entry) => ({
+		...entry,
+		ignored_reason: null
+	})), ...(ignored ?? []).map(ignoredRow)];
+	const lines = [HISTORY_CSV_COLUMNS.join(",")];
+	for (const row of rows) lines.push(HISTORY_CSV_COLUMNS.map((column) => csvField(row[column])).join(","));
+	return `${BOM}${lines.map((line) => `${line}\r\n`).join("")}`;
+}
 //#endregion
 //#region ../../packages/crypto/dist/encoding.js
 const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
@@ -9790,9 +12694,4 @@ function gitBlobId(bytes, algorithm = "sha1") {
 	return toHex(algorithm === "sha1" ? sha1(object) : sha256$1(object));
 }
 //#endregion
-//#region ../../packages/crypto/dist/webauthn.js
-/** Relying party of every `presence` credential. */
-const WEBAUTHN_RP_ID = "agentplugged.local";
-const WEBAUTHN_ORIGIN = `https://${WEBAUTHN_RP_ID}`;
-//#endregion
-export { MAX_SPRINT_CHECKPOINT_SUMMARY as $, InstallSettingsSchema as $a, RequestCreatorActionInputSchema as $i, STORY_DOCUMENT_ID_PATTERN as $n, REVIEW_LENSES as $r, KNOWLEDGE_CODE_FIELD as $t, REQUIREMENT_STATUSES as A, DeferredIdInputSchema as Aa, hasHiddenCharacter as Ai, SOLO_METHODS as An, resolveGitWorkflow as Ao, AgentOverrideSchema as Ar, HYPOTHESIS_CONFIDENCES as At, RoomIdSchema as B, ReportProgressInputSchema as Ba, ReadMemoryInputSchema as Bi, courseIdOf as Bn, ErrorCode as Bo, qaProofKind as Br, journalRemoteRef as Bt, USAGE_EVENT_TYPES as C, contentSize as Ca, CheckActionInputSchema as Ci, DelegateInputSchema as Cn, issueName as Co, QUESTION_TOOL_VIA as Cr, MigrationStepIdSchema as Ct, DeviationIdInputSchema as D, CompleteDeferredInputSchema as Da, PUBLICATION_DOCS_DIR as Di, CritiqueInputSchema as Dn, GitBranchSchema as Do, BUDGET_EVENT_TYPES as Dr, MERGE_ORDER_EVENT_TYPES as Dt, DEVIATION_EVENT_TYPES as E, plainLine as Ea, SESSION_EVENT_TYPES as Ei, CRITIQUE_EVENT_TYPES as En, GIT_MERGE_MODES as Eo, QuestionToolViaSchema as Er, GetMergeOrderInputSchema as Et, deviationIdOf as F, hasControlCharacter as Fa, MEMORY_EVENT_TYPES as Fi, isCritiqueGesture as Fn, ULID_PATTERN as Fo, MAX_QA_PROOF_BYTES as Fr, JOURNAL_DIR as Ft, THREE_VIEWS_AGENTS as G, AgentIdSchema as Ga, retroIdOf as Gi, DOCUMENT_ID_PATTERN as Gn, REQUIREMENT_EVENT_TYPES as Gr, PresenceCredentialSchema as Gt, RoundTableInputSchema as H, StoryIdSchema as Ha, actionIdOf as Hi, ArchitectureHeaderSchema as Hn, RecordCriterionInputSchema as Hr, HUMAN_DEVICE_PATTERN as Ht, ReviewTestsInputSchema as I, AGENT_EVENT_TYPES as Ia, PROMOTION_TITLE as Ii, isHypothesisOutcome as In, eventInvalid as Io, QA_COMMAND as Ir, JOURNAL_REF as It, AnswerStackInputSchema as J, DEFAULT_VALIDATION_MODE as Ja, CREATOR_ACTION_EVENT_TYPES as Ji, EPIC_DOCUMENT_ID_PATTERN as Jn, SubmitAuditInputSchema as Jr, FAST_TRACK_OPTIONS as Jt, flatTable as K, DEFAULT_INSTALL_MODE as Ka, retroTitle as Ki, DOCUMENT_KINDS as Kn, RecordProofInputSchema as Kr, FAST_TRACK_ENGINE_REASONS as Kt, TEST_CRITERIA as L, MAIN_SESSION_AGENT as La, PromoteLessonInputSchema as Li, COURSE_EVENT_TYPES as Ln, jsonValueIssue as Lo, QA_EVENT_TYPES as Lr, MACHINE_DEVICE_PATTERN as Lt, ResolveDeviationInputSchema as M, canonicalStoryId as Ma, CommonLessonIdSchema as Mi, critiquePathOf as Mn, EVENT_REASON as Mo, AgentFrontmatterSchema as Mr, LOOP_EVENT_TYPES as Mt, TRACED_REQUIREMENT_PATTERN as N, compareStoryIds as Na, LESSON_EVENT_TYPES as Ni, critiqueStepOf as Nn, EVENT_TYPE_PATTERN as No, SkillFrontmatterSchema as Nr, LoopInputSchema as Nt, DeviationReasonSchema as O, DEFERRED_EVENT_TYPES as Oa, PUBLICATION_EXPORT_DIR as Oi, IDEA_VERSION as On, GitWorkflowSchema as Oo, BUDGET_TITLE_PREFIX as Or, QualifyMergeConflictInputSchema as Ot, TracedRequirementInputSchema as P, deferredIdOf as Pa, MEMORY_APPROVING_DECISIONS as Pi, hypothesisIdOf as Pn, SIGNATURE_REASON as Po, AcceptanceQaInputSchema as Pr, EVENT_TYPES as Pt, stackIdOf as Q, INSTALL_MODES as Qa, FORGE_CREATOR_ACTIONS as Qi, REQUIREMENT_ID_PATTERN as Qn, REVIEW_EVENT_TYPES as Qr, DEFAULT_MERGE_METHOD as Qt, TEST_REVIEW_EVENT_TYPES as R, NextInputSchema as Ra, ProposePromotionInputSchema as Ri, COURSE_KINDS as Rn, parseEventEnvelope as Ro, QA_PROOF_DIR as Rr, RESERVED_EVENT_TYPES as Rt, MeasureUsageInputSchema as S, contentSections as Sa, checkpointIdOf as Si, DELEGATION_EVENT_TYPES as Sn, ISSUE as So, QUESTION_TOOL_NAME as Sr, METHOD_EVENT_TYPES as St, UsageMeasuredPayloadSchema as T, isSkillOverrideContent as Ta, RequestActionInputSchema as Ti, CRITIQUE_DOCUMENT_KINDS as Tn, GIT_EVENT_TYPES as To, QuestionStackProofSchema as Tr, CONFLICT_OPTIONS as Tt, TABLE_ANGLES as U, SubmitResultInputSchema as Ua, commonIdOf as Ui, CREATOR_OWNER as Un, criteriaInLine as Ur, HUMAN_EVENT_TYPES as Ut, RoomSchema as V, ReportStatusInputSchema as Va, RecordLessonsInputSchema as Vi, parseCourseStart as Vn, CRITERION_EVENT_TYPES as Vr, journalSeenRef as Vt, TABLE_EVENT_TYPES as W, UpdateStoryInputSchema as Wa, lessonIdOf as Wi, DOCUMENT_DIRS as Wn, criterionId as Wr, HUMAN_ONLY_EVENT_TYPES as Wt, OpenStackInputSchema as X, DEVELOPER_SPECIALTIES as Xa, CreatorActionSchema as Xi, KNOWLEDGE_SOURCES_FIELD as Xn, JUDGE_LENS as Xr, StartStoryFastTrackInputSchema as Xt, AskStackInputSchema as Y, DEFAULT_VALIDATION_POINTS as Ya, CREATOR_ACTION_KINDS as Yi, EpicHeaderSchema as Yn, SyncRequirementsInputSchema as Yr, LeaveFastTrackInputSchema as Yt, STACK_EVENT_TYPES as Z, DOMAIN_IDS as Za, FILE_CREATOR_ACTIONS as Zi, KnowledgeSourceSchema as Zn, REVIEW_DOMAINS as Zr, missingDeclarations as Zt, currentEvent as _, AgentContentSchema as _a, NOTE_REQUIRED as _i, devicePairedRecord as _n, INHERIT_MODEL as _o, AnswerCheckpointInputSchema as _r, ReadSensitiveInputSchema as _t, sha256 as a, REVIEW_SKILLS as aa, findingIdOf as ai, RepositoryPathSchema as an, PullRequestSettingsSchema as ao, INSTALL_EVENT_TYPES as ar, READINESS_EVENT_TYPES as at, isSensitiveEventType as b, SKILL_OVERRIDE_FIELDS as ba, RESOLUTION_DECISIONS as bi, pairOfferRecord as bn, ModelTableSchema as bo, CHAT_RETENTION_MS as br, isSensitivePath as bt, fromUtf8 as c, RunProofCommandInputSchema as ca, reviewIdOf as ci, ELICITATION_TIMEOUT_MS as cn, RulesSchema as co, CheckCiInputSchema as cr, ReadyInputSchema as ct, utf8 as d, isStoryStep as da, STORY_EVENT_TYPES as di, BRIDGE_ID_PATTERN as dn, TEST_FILE_MAX_LINES as do, CiWaiverReasonSchema as dr, ENCRYPTED_FILE_PREFIX as dt, engineUpdateRisk as ea, SECURITY_REASONS as ei, KNOWLEDGE_STORY_FIELD as en, MethodConfigSchema as eo, STORY_SECTIONS as er, MAX_SPRINT_USD as et, ClaudeSettingsSchema as f, ARCHITECTURE_PREREQUISITES_FIELD as fa, isStoryBranch as fi, DEVICE_TRUST_EVENT_TYPES as fn, TOOL_IDS as fo, MAX_CI_CHECKS as fr, KEY_ID_PATTERN as ft, JOURNAL_PROJECTED_REF as g, PrerequisitesSchema as ga, LIFTING_DECISIONS as gi, deviceKindOf as gn, ValidationSettingsSchema as go, ANTICIPATED_ANSWER_WINDOW_MS as gr, PRODUCT_KEY_EXPORT_PREFIX as gt, GetStateInputSchema as h, PrerequisiteVersionSchema as ha, CheckpointIdSchema as hi, TRUST_SIGNATURE_TAGS as hn, VALIDATION_POINTS as ho, CHECKPOINT_CLOSED_EVENT_TYPES as hr, PRODUCT_KEY_EVENT_TYPES as ht, randomBytes as i, WRITE_TEXT_MAX as ia, TriageReviewInputSchema as ii, MERGE_EVENT_TYPES as in, ProfileSchema as io, DependenciesSchema as ir, sprintIdOf as it, ReportDeviationInputSchema as j, DeferredReasonSchema as ja, hasMisleadingControl as ji, critiqueIdOf as jn, sameWorkflow as jo, menuKey as jr, HYPOTHESIS_KIND as jt, GetTraceInputSchema as k, DeferWorkInputSchema as ka, countWords as ki, RECONCILE_KINDS as kn, recommendedGitWorkflow as ko, AgentDefinitionSchema as kr, SUBSTANTIVE_CLASSES as kt, toBase64url as l, normalizedFolder as la, CommitIdSchema as li, ElicitationChannelSchema as ln, SemverSchema as lo, CiReportedPayloadSchema as lr, readinessIdOf as lt, SyncManifestSchema as m, PrerequisiteCommandSchema as ma, CONFIRMATION_MODES as mi, RootPinSchema as mn, VALIDATION_MODES as mo, DecideCheckpointInputSchema as mr, PAYLOAD_ENCRYPTION_ALG as mt, WEBAUTHN_RP_ID as n, CheckWriteInputSchema as na, StoryReviewInputSchema as ni, KnowledgeStorySchema as nn, PHASE_IDS as no, epicIdOf as nr, SPRINT_EVENT_TYPES as nt, sha256Hex as o, SkillOverrideSchema as oa, isSilentJudge as oi, AskCreatorInputSchema as on, RULE_ACTIONS as oo, CI_EVENT_TYPES as or, READINESS_FIX_FIRST as ot, CursorCliConfigSchema as p, EnvironmentCheckIdSchema as pa, CHECKPOINT_EVENT_TYPES as pi, DEVICE_TRUST_SYSTEM_EVENT_TYPES as pn, TestSettingsSchema as po, CHECKPOINT_DECIDED_EVENT_TYPES as pr, MAX_SENSITIVE_CONTENT_BYTES as pt, roundTableStepOf as q, DEFAULT_PERMISSION_MODE as qa, scopeLabel as qi, DocumentHeaderSchema as qn, SettleGapInputSchema as qr, FAST_TRACK_EVENT_TYPES as qt, gitBlobId as r, WRITE_GUARD_EVENT_TYPES as ra, SubmitReviewInputSchema as ri, MAX_MERGED_FILES as rn, PROFILE_PRESET_IDS as ro, ARCHITECTURE_DEPENDENCIES_FIELD as rr, SPRINT_TITLE_PREFIX as rt, fromBase64url as s, ProofsFileSchema as sa, isSilentLens as si, ELICITATION_EVENT_TYPES as sn, RULE_VALUES as so, CI_FORGES as sr, READINESS_GO_ON as st, WEBAUTHN_ORIGIN as t, proofCommandsRisk as ta, StartReviewInputSchema as ti, KnowledgeCodeSchema as tn, PERMISSION_MODES as to, StoryHeaderSchema as tr, PlanSprintInputSchema as tt, toHex as u, PHASE_STEPS as ua, OpenPullRequestInputSchema as ui, MAX_ELICITED_NOTE_LENGTH as un, SkillNameSchema as uo, CiUrlSchema as ur, readinessStepOf as ut, eventTypeSpec as v, FORM_CONTENT_MAX_CHARS as va, OpenCheckpointInputSchema as vi, deviceRevokedRecord as vn, MODEL_CLIENT_IDS as vo, CHAT_DECISIONS as vr, SENSITIVE_AREAS as vt, USAGE_SOURCES as w, isSkillContent as wa, RecordExternalReadInputSchema as wi, NOAH_AGENT as wn, GIT_CI_MODES as wo, QuestionProofSchema as wr, CONFLICT_CLASSES as wt, isTestEventType as x, SkillContentSchema as xa, ReportMeasuresInputSchema as xi, rootCertifiedRecord as xn, NO_EFFORT as xo, MessageDigestSchema as xr, utf8Length as xt, eventTypeUpgrade as y, REQUIRED_CONTENT_FIELDS as ya, RECIPIENT_ROLES as yi, isTrustSignatureTag as yn, MODEL_TIERS as yo, CHAT_EVENT_TYPES as yr, WriteSensitiveInputSchema as yt, TEST_ROWS as z, ReportCostInputSchema as za, ProposeRetrospectiveInputSchema as zi, CourseInputSchema as zn, TEST_EVENT_TYPE as zo, qaProofBelongs as zr, journalEventPath as zt };
+export { readinessIdOf as $, UpdateStoryInputSchema as $a, lessonIdOf as $i, CI_EVENT_TYPES as $n, criterionId as $r, RepositoryPathSchema as $t, RoomIdSchema as A, SkillContentSchema as Aa, ReportMeasuresInputSchema as Ai, COURSE_EVENT_TYPES as An, MODEL_TIERS as Ao, CHAT_RETENTION_MS as Ar, JOURNAL_REF as At, OpenStackInputSchema as B, DeferredReasonSchema as Ba, hasMisleadingControl as Bi, DocumentHeaderSchema as Bn, recommendedGitWorkflow as Bo, menuKey as Br, FAST_TRACK_ENGINE_REASONS as Bt, USAGE_EVENT_TYPES as C, PrerequisiteCommandSchema as Ca, CONFIRMATION_MODES as Ci, SOLO_METHODS as Cn, TestSettingsSchema as Co, isTrustSignatureTag as Cr, MACHINE_EVENT_TYPES as Ct, TEST_CRITERIA as D, FORM_CONTENT_MAX_CHARS as Da, OpenCheckpointInputSchema as Di, hypothesisIdOf as Dn, INHERIT_MODEL as Do, AnswerCheckpointInputSchema as Dr, LoopInputSchema as Dt, ReviewTestsInputSchema as E, AgentContentSchema as Ea, NOTE_REQUIRED as Ei, critiqueStepOf as En, ValidationSettingsSchema as Eo, ANTICIPATED_ANSWER_WINDOW_MS as Er, LOOP_EVENT_TYPES as Et, THREE_VIEWS_AGENTS as F, plainLine as Fa, SESSION_EVENT_TYPES as Fi, ArchitectureHeaderSchema as Fn, GIT_CI_MODES as Fo, QuestionStackProofSchema as Fr, journalSeenRef as Ft, PlanSprintInputSchema as G, AGENT_EVENT_TYPES as Ga, PROMOTION_TITLE as Gi, REQUIREMENT_ID_PATTERN as Gn, SIGNATURE_REASON as Go, QA_COMMAND as Gr, missingDeclarations as Gt, stackIdOf as H, compareStoryIds as Ha, LESSON_EVENT_TYPES as Hi, EpicHeaderSchema as Hn, sameWorkflow as Ho, SkillFrontmatterSchema as Hr, FAST_TRACK_OPTIONS as Ht, flatTable as I, CompleteDeferredInputSchema as Ia, PUBLICATION_DOCS_DIR as Ii, CREATOR_OWNER as In, GIT_EVENT_TYPES as Io, QuestionToolViaSchema as Ir, HUMAN_DEVICE_PATTERN as It, sprintIdOf as J, ReportCostInputSchema as Ja, ProposeRetrospectiveInputSchema as Ji, StoryHeaderSchema as Jn, jsonValueIssue as Jo, qaProofBelongs as Jr, KNOWLEDGE_STORY_FIELD as Jt, SPRINT_EVENT_TYPES as K, MAIN_SESSION_AGENT as Ka, PromoteLessonInputSchema as Ki, STORY_DOCUMENT_ID_PATTERN as Kn, ULID_PATTERN as Ko, QA_EVENT_TYPES as Kr, DEFAULT_MERGE_METHOD as Kt, roundTableStepOf as L, DEFERRED_EVENT_TYPES as La, PUBLICATION_EXPORT_DIR as Li, DOCUMENT_DIRS as Ln, GIT_MERGE_MODES as Lo, RULE_LOCKS as Lr, HUMAN_EVENT_TYPES as Lt, RoundTableInputSchema as M, contentSize as Ma, CheckActionInputSchema as Mi, CourseInputSchema as Mn, NO_EFFORT as Mo, QUESTION_TOOL_NAME as Mr, RESERVED_EVENT_TYPES as Mt, TABLE_ANGLES as N, isSkillContent as Na, RecordExternalReadInputSchema as Ni, courseIdOf as Nn, ISSUE as No, QUESTION_TOOL_VIA as Nr, journalEventPath as Nt, TEST_REVIEW_EVENT_TYPES as O, REQUIRED_CONTENT_FIELDS as Oa, RECIPIENT_ROLES as Oi, isCritiqueGesture as On, LEGACY_GEMINI_CLIENT as Oo, CHAT_DECISIONS as Or, EVENT_TYPES as Ot, TABLE_EVENT_TYPES as P, isSkillOverrideContent as Pa, RequestActionInputSchema as Pi, parseCourseStart as Pn, issueName as Po, QuestionProofSchema as Pr, journalRemoteRef as Pt, ReadyInputSchema as Q, SubmitResultInputSchema as Qa, commonIdOf as Qi, INSTALL_EVENT_TYPES as Qn, criteriaInLine as Qr, MERGE_EVENT_TYPES as Qt, AnswerStackInputSchema as R, DeferWorkInputSchema as Ra, countWords as Ri, DOCUMENT_ID_PATTERN as Rn, GitBranchSchema as Ro, AgentDefinitionSchema as Rr, HUMAN_ONLY_EVENT_TYPES as Rt, MeasureUsageInputSchema as S, EnvironmentCheckIdSchema as Sa, CHECKPOINT_EVENT_TYPES as Si, RECONCILE_KINDS as Sn, TOOL_IDS as So, deviceRevokedRecord as Sr, SUBSTANTIVE_CLASSES as St, UsageMeasuredPayloadSchema as T, PrerequisitesSchema as Ta, LIFTING_DECISIONS as Ti, critiquePathOf as Tn, VALIDATION_POINTS as To, rootCertifiedRecord as Tr, HYPOTHESIS_KIND as Tt, MAX_SPRINT_CHECKPOINT_SUMMARY as U, deferredIdOf as Ua, MEMORY_APPROVING_DECISIONS as Ui, KNOWLEDGE_SOURCES_FIELD as Un, EVENT_REASON as Uo, AcceptanceQaInputSchema as Ur, LeaveFastTrackInputSchema as Ut, STACK_EVENT_TYPES as V, canonicalStoryId as Va, CommonLessonIdSchema as Vi, EPIC_DOCUMENT_ID_PATTERN as Vn, resolveGitWorkflow as Vo, AgentFrontmatterSchema as Vr, FAST_TRACK_EVENT_TYPES as Vt, MAX_SPRINT_USD as W, hasControlCharacter as Wa, MEMORY_EVENT_TYPES as Wi, KnowledgeSourceSchema as Wn, EVENT_TYPE_PATTERN as Wo, MAX_QA_PROOF_BYTES as Wr, StartStoryFastTrackInputSchema as Wt, READINESS_FIX_FIRST as X, ReportStatusInputSchema as Xa, RecordLessonsInputSchema as Xi, ARCHITECTURE_DEPENDENCIES_FIELD as Xn, TEST_EVENT_TYPE as Xo, CRITERION_EVENT_TYPES as Xr, KnowledgeStorySchema as Xt, READINESS_EVENT_TYPES as Y, ReportProgressInputSchema as Ya, ReadMemoryInputSchema as Yi, epicIdOf as Yn, parseEventEnvelope as Yo, qaProofKind as Yr, KnowledgeCodeSchema as Yt, READINESS_GO_ON as Z, StoryIdSchema as Za, actionIdOf as Zi, DependenciesSchema as Zn, ErrorCode as Zo, RecordCriterionInputSchema as Zr, MAX_MERGED_FILES as Zt, currentEvent as _, RunProofCommandInputSchema as _a, reviewIdOf as _i, NOAH_AGENT as _n, RULE_VALUES as _o, DEVICE_TRUST_SYSTEM_EVENT_TYPES as _r, CONFLICT_CLASSES as _t, fromBase64url as a, CreatorActionSchema as aa, JUDGE_LENS as ai, DEVIATION_EVENT_TYPES as an, DEVELOPER_SPECIALTIES as ao, MAX_CI_CHECKS as ar, PRODUCT_KEYS_EXPORT_PREFIX as at, isSensitiveEventType as b, isStoryStep as ba, STORY_EVENT_TYPES as bi, CritiqueInputSchema as bn, SkillNameSchema as bo, deviceKindOf as br, MERGE_ORDER_EVENT_TYPES as bt, toHex as c, RequestCreatorActionInputSchema as ca, REVIEW_LENSES as ci, GetTraceInputSchema as cn, InstallSettingsSchema as co, CHECKPOINT_CLOSED_EVENT_TYPES as cr, ProductKeyRotatedPayloadSchema as ct, ClaudeSettingsSchema as d, CheckWriteInputSchema as da, StoryReviewInputSchema as di, ResolveDeviationInputSchema as dn, PHASE_IDS as do, BUDGET_TITLE_PREFIX as dr, WriteSensitiveInputSchema as dt, retroIdOf as ea, REQUIREMENT_EVENT_TYPES as ei, AskCreatorInputSchema as en, AgentIdSchema as eo, CI_FORGES as er, readinessStepOf as et, CursorCliConfigSchema as f, WRITE_GUARD_EVENT_TYPES as fa, SubmitReviewInputSchema as fi, TRACED_REQUIREMENT_PATTERN as fn, PROFILE_PRESET_IDS as fo, WEB_ANSWER_EVENT_TYPES as fr, isSensitivePath as ft, JOURNAL_PROJECTED_REF as g, ProofsFileSchema as ga, isSilentLens as gi, DelegateInputSchema as gn, RULE_ACTIONS as go, DEVICE_TRUST_EVENT_TYPES as gr, MigrationStepIdSchema as gt, REDACTED_SECRET as h, SkillOverrideSchema as ha, isSilentJudge as hi, DELEGATION_EVENT_TYPES as hn, PullRequestSettingsSchema as ho, BRIDGE_ID_PATTERN as hr, METHOD_EVENT_TYPES as ht, sha256Hex as i, CREATOR_ACTION_KINDS as ia, SyncRequirementsInputSchema as ii, MAX_ELICITED_NOTE_LENGTH as in, DEFAULT_VALIDATION_POINTS as io, CiWaiverReasonSchema as ir, PAYLOAD_ENCRYPTION_ALG as it, RoomSchema as j, contentSections as ja, checkpointIdOf as ji, COURSE_KINDS as jn, ModelTableSchema as jo, MessageDigestSchema as jr, MACHINE_DEVICE_PATTERN as jt, TEST_ROWS as k, SKILL_OVERRIDE_FIELDS as ka, RESOLUTION_DECISIONS as ki, isHypothesisOutcome as kn, MODEL_CLIENT_IDS as ko, CHAT_EVENT_TYPES as kr, JOURNAL_DIR as kt, utf8 as l, engineUpdateRisk as la, SECURITY_REASONS as li, REQUIREMENT_STATUSES as ln, MethodConfigSchema as lo, CHAIN_EVENT_TYPES as lr, ReadSensitiveInputSchema as lt, GetStateInputSchema as m, REVIEW_SKILLS as ma, findingIdOf as mi, deviationIdOf as mn, ProfileSchema as mo, WEB_ANSWER_WINDOW_MS as mr, ORDER_EVENT_TYPES as mt, randomBytes as n, scopeLabel as na, SettleGapInputSchema as ni, ELICITATION_TIMEOUT_MS as nn, DEFAULT_PERMISSION_MODE as no, CiReportedPayloadSchema as nr, KEY_ID_PATTERN as nt, fromUtf8 as o, FILE_CREATOR_ACTIONS as oa, REVIEW_DOMAINS as oi, DeviationIdInputSchema as on, DOMAIN_IDS as oo, CHECKPOINT_DECIDED_EVENT_TYPES as or, PRODUCT_KEY_EVENT_TYPES as ot, SyncManifestSchema as p, WRITE_TEXT_MAX as pa, TriageReviewInputSchema as pi, TracedRequirementInputSchema as pn, PROFILE_PRESET_SPECS as po, WEB_ANSWER_STALE_MS as pr, utf8Length as pt, SPRINT_TITLE_PREFIX as q, NextInputSchema as qa, ProposePromotionInputSchema as qi, STORY_SECTIONS as qn, eventInvalid as qo, QA_PROOF_DIR as qr, KNOWLEDGE_CODE_FIELD as qt, sha256 as r, CREATOR_ACTION_EVENT_TYPES as ra, SubmitAuditInputSchema as ri, ElicitationChannelSchema as rn, DEFAULT_VALIDATION_MODE as ro, CiUrlSchema as rr, MAX_SENSITIVE_CONTENT_BYTES as rt, toBase64url as s, FORGE_CREATOR_ACTIONS as sa, REVIEW_EVENT_TYPES as si, DeviationReasonSchema as sn, INSTALL_MODES as so, DecideCheckpointInputSchema as sr, PRODUCT_KEY_EXPORT_PREFIX as st, gitBlobId as t, retroTitle as ta, RecordProofInputSchema as ti, ELICITATION_EVENT_TYPES as tn, DEFAULT_INSTALL_MODE as to, CheckCiInputSchema as tr, ENCRYPTED_FILE_PREFIX as tt, historyCsv as u, proofCommandsRisk as ua, StartReviewInputSchema as ui, ReportDeviationInputSchema as un, PERMISSION_MODES as uo, BUDGET_EVENT_TYPES as ur, SENSITIVE_AREAS as ut, eventTypeSpec as v, normalizedFolder as va, CommitIdSchema as vi, CRITIQUE_DOCUMENT_KINDS as vn, RulesSchema as vo, RootPinSchema as vr, CONFLICT_OPTIONS as vt, USAGE_SOURCES as w, PrerequisiteVersionSchema as wa, CheckpointIdSchema as wi, critiqueIdOf as wn, VALIDATION_MODES as wo, pairOfferRecord as wr, HYPOTHESIS_CONFIDENCES as wt, isTestEventType as x, ARCHITECTURE_PREREQUISITES_FIELD as xa, isStoryBranch as xi, IDEA_VERSION as xn, TEST_FILE_MAX_LINES as xo, devicePairedRecord as xr, QualifyMergeConflictInputSchema as xt, eventTypeUpgrade as y, PHASE_STEPS as ya, OpenPullRequestInputSchema as yi, CRITIQUE_EVENT_TYPES as yn, SemverSchema as yo, TRUST_SIGNATURE_TAGS as yr, GetMergeOrderInputSchema as yt, AskStackInputSchema as z, DeferredIdInputSchema as za, hasHiddenCharacter as zi, DOCUMENT_KINDS as zn, GitWorkflowSchema as zo, AgentOverrideSchema as zr, PresenceCredentialSchema as zt };