- {[
- { label: "Budget ask", value: draft.budget },
- {
- label: "Formation",
- value: draft.formationEligible ? "Yes" : "No",
- },
- {
- label: "Team slots",
- value: `${draft.teamSlots} (open: ${openSlots})`,
- },
- {
- label: "Milestones",
- value: draft.milestonesPlanned,
- },
- ].map((item) => (
-
- ))}
-
-
-
-
- Team (locked)
-
- {draft.teamLocked.map((member) => (
-
- {member.name}
- {member.role}
-
- ))}
-
-
-
- Open slots (positions)
-
- {draft.openSlotNeeds.map((slot) => (
-
- {slot.title}
- {slot.desc}
-
- ))}
-
-
+
+
+
+
+ {draft.publication.status === "submitted"
+ ? "Draft history"
+ : "Draft"}
+
+ {draft.publication.revision ? (
+ Public revision {draft.publication.revision}
+ ) : null}
+
+
+
+
-
- Milestones
-
- {draft.milestonesDetail.map((milestone) => (
-
- {milestone.title}
- {milestone.desc}
-
- ))}
-
-
-
- ({
- id: file.title,
- title: file.title,
- href: file.href,
- }))}
- />
-
-
+ ({
+ id: `draft-attachment-${index + 1}`,
+ title: attachment.title,
+ href: attachment.href,
+ }))}
+ authoring={draft.authoring}
+ budgetScope={draft.budgetScope}
+ executionPlan={draft.executionPlan}
+ milestonesDetail={
+ draft.formationEligible ? draft.milestonesDetail : undefined
+ }
+ openSlots={draft.formationEligible ? draft.openSlotNeeds : undefined}
+ overview={draft.overview}
+ showBudgetScope={draft.formationEligible}
+ showExecutionPlan
+ stats={[
+ { label: "Budget ask", value: draft.budget },
+ { label: "Formation", value: draft.formationEligible ? "Yes" : "No" },
+ ...(draft.formationEligible
+ ? [
+ {
+ label: "Team slots",
+ value: `${draft.teamSlots} (${openSlots} available)`,
+ },
+ { label: "Milestones", value: draft.milestonesPlanned },
+ ]
+ : []),
+ ]}
+ summary={draft.summary}
+ teamLocked={draft.formationEligible ? draft.teamLocked : undefined}
+ />
+
);
};
diff --git a/src/pages/proposals/draft/PublicDraftCard.tsx b/src/pages/proposals/draft/PublicDraftCard.tsx
new file mode 100644
index 0000000..500787a
--- /dev/null
+++ b/src/pages/proposals/draft/PublicDraftCard.tsx
@@ -0,0 +1,56 @@
+import { useState } from "react";
+import { Link } from "react-router";
+
+import { AddressInline } from "@/components/AddressInline";
+import { GlassyRecordCard } from "@/components/GlassyRecordCard";
+import { Button } from "@/components/primitives/button";
+import { StatTile } from "@/components/StatTile";
+import { formatDateTime } from "@/lib/dateTime";
+import type { PublicProposalDraftListItemDto } from "@/types/api";
+import { publicDraftKindLabels, publicDraftRoute } from "./draftUi";
+
+type PublicDraftCardProps = {
+ draft: PublicProposalDraftListItemDto;
+};
+
+export function PublicDraftCard({ draft }: PublicDraftCardProps) {
+ const [expanded, setExpanded] = useState(false);
+ return (
+
setExpanded((current) => !current)}
+ stage="draft"
+ summary={draft.summary}
+ title={draft.title}
+ >
+
+
+ );
+}
diff --git a/src/pages/proposals/draft/PublicDraftsSection.tsx b/src/pages/proposals/draft/PublicDraftsSection.tsx
new file mode 100644
index 0000000..101596e
--- /dev/null
+++ b/src/pages/proposals/draft/PublicDraftsSection.tsx
@@ -0,0 +1,24 @@
+import { GlassySection } from "@/components/GlassySection";
+import type { PublicProposalDraftListItemDto } from "@/types/api";
+import { PublicDraftCard } from "./PublicDraftCard";
+
+type PublicDraftsSectionProps = {
+ drafts: PublicProposalDraftListItemDto[];
+ title?: string;
+};
+
+export function PublicDraftsSection({
+ drafts,
+ title = "Public drafts",
+}: PublicDraftsSectionProps) {
+ if (drafts.length === 0) return null;
+ return (
+
+
+ {drafts.map((draft) => (
+
+ ))}
+
+ );
+}
diff --git a/src/pages/proposals/draft/draftUi.ts b/src/pages/proposals/draft/draftUi.ts
new file mode 100644
index 0000000..96ada67
--- /dev/null
+++ b/src/pages/proposals/draft/draftUi.ts
@@ -0,0 +1,66 @@
+import type {
+ DraftPublicationSummaryDto,
+ PublicProposalDraftKindDto,
+} from "@/types/api";
+
+export const proposalDraftRoutes = {
+ create: "/app/proposals/new",
+ mine: "/app/proposals/drafts",
+ proposals: "/app/proposals",
+ public: "/app/proposals/public-drafts",
+} as const;
+
+export function ownerDraftRoute(draftId: string): string {
+ return `${proposalDraftRoutes.mine}/${encodeURIComponent(draftId)}`;
+}
+
+export function editDraftRoute(draftId: string): string {
+ return `${proposalDraftRoutes.create}?draftId=${encodeURIComponent(draftId)}`;
+}
+
+export function reconsiderProposalRoute(proposalId: string): string {
+ return `${proposalDraftRoutes.create}?resubmitsProposalId=${encodeURIComponent(proposalId)}`;
+}
+
+export function publicDraftRoute(draftId: string): string {
+ return `${proposalDraftRoutes.public}/${encodeURIComponent(draftId)}`;
+}
+
+export function publicationRoute(
+ draftId: string,
+ publication: DraftPublicationSummaryDto,
+): string {
+ return publication.publicUrl ?? publicDraftRoute(draftId);
+}
+
+export function canPublishDraft(
+ publication: DraftPublicationSummaryDto,
+): boolean {
+ return (
+ publication.status === "private" ||
+ publication.status === "withdrawn" ||
+ (publication.status === "published" &&
+ Boolean(publication.hasUnpublishedChanges))
+ );
+}
+
+export function isPublicDraftVisible(
+ publication: DraftPublicationSummaryDto,
+): boolean {
+ return (
+ publication.status === "published" || publication.status === "submitted"
+ );
+}
+
+export const publicDraftKindLabels: Record
=
+ {
+ policy: "Policy",
+ formation: "Formation",
+ system: "System change",
+ };
+
+export const publicDraftKindOptions = (
+ Object.entries(publicDraftKindLabels) as Array<
+ [PublicProposalDraftKindDto, string]
+ >
+).map(([value, label]) => ({ value, label }));
diff --git a/src/pages/proposals/draft/useDraftPublicationActions.ts b/src/pages/proposals/draft/useDraftPublicationActions.ts
new file mode 100644
index 0000000..a52cf36
--- /dev/null
+++ b/src/pages/proposals/draft/useDraftPublicationActions.ts
@@ -0,0 +1,107 @@
+import { useEffect, useRef, useState } from "react";
+
+import {
+ apiProposalDraftPublish,
+ apiProposalDraftUnpublish,
+} from "@/lib/apiClient";
+import { formatLoadError } from "@/lib/errorFormatting";
+import type { DraftPublicationSummaryDto } from "@/types/api";
+import { canPublishDraft, publicationRoute } from "./draftUi";
+
+type PublicationAction = "publish" | "unpublish";
+
+type UseDraftPublicationActionsInput = {
+ draftId: string;
+ publication: DraftPublicationSummaryDto;
+ onChanged?: (publication: DraftPublicationSummaryDto) => void;
+};
+
+export function useDraftPublicationActions({
+ draftId,
+ publication,
+ onChanged,
+}: UseDraftPublicationActionsInput) {
+ const [pending, setPending] = useState(null);
+ const [error, setError] = useState(null);
+ const currentDraftId = useRef(draftId);
+ const actionKeys = useRef>>({});
+ currentDraftId.current = draftId;
+
+ useEffect(() => {
+ setPending(null);
+ setError(null);
+ actionKeys.current = {};
+ }, [draftId]);
+
+ const publish = async () => {
+ if (pending) return;
+ setPending("publish");
+ setError(null);
+ try {
+ actionKeys.current.publish ??= `draft-publish-${crypto.randomUUID()}`;
+ const response = await apiProposalDraftPublish({
+ draftId,
+ idempotencyKey: actionKeys.current.publish,
+ });
+ if (currentDraftId.current !== draftId) return;
+ onChanged?.({
+ status: "published",
+ revision: response.revision,
+ publicUrl: response.publicUrl,
+ publishedAt: response.publishedAt,
+ publicUpdatedAt: response.updatedAt,
+ hasUnpublishedChanges: false,
+ });
+ actionKeys.current.publish = undefined;
+ } catch (nextError) {
+ setError(
+ formatLoadError(
+ nextError instanceof Error ? nextError.message : null,
+ "Could not publish this draft.",
+ ),
+ );
+ } finally {
+ if (currentDraftId.current === draftId) setPending(null);
+ }
+ };
+
+ const unpublish = async () => {
+ if (pending || publication.status !== "published") return;
+ if (!window.confirm("Remove this draft from public view?")) return;
+ setPending("unpublish");
+ setError(null);
+ try {
+ actionKeys.current.unpublish ??= `draft-unpublish-${crypto.randomUUID()}`;
+ await apiProposalDraftUnpublish({
+ draftId,
+ idempotencyKey: actionKeys.current.unpublish,
+ });
+ if (currentDraftId.current !== draftId) return;
+ onChanged?.({
+ ...publication,
+ status: "withdrawn",
+ hasUnpublishedChanges: false,
+ });
+ actionKeys.current.unpublish = undefined;
+ } catch (nextError) {
+ setError(
+ formatLoadError(
+ nextError instanceof Error ? nextError.message : null,
+ "Could not unpublish this draft.",
+ ),
+ );
+ } finally {
+ if (currentDraftId.current === draftId) setPending(null);
+ }
+ };
+
+ return {
+ canPublish: canPublishDraft(publication),
+ error,
+ pending,
+ publicUrl: publicationRoute(draftId, publication),
+ publish,
+ reportError: setError,
+ unpublish,
+ };
+}
diff --git a/src/pages/proposals/draft/usePublicDrafts.ts b/src/pages/proposals/draft/usePublicDrafts.ts
new file mode 100644
index 0000000..8d4b3bf
--- /dev/null
+++ b/src/pages/proposals/draft/usePublicDrafts.ts
@@ -0,0 +1,43 @@
+import { useEffect, useState } from "react";
+
+import { apiPublicProposalDrafts } from "@/lib/apiClient";
+import type { PublicProposalDraftListItemDto } from "@/types/api";
+
+type PublicDraftFilters = {
+ author?: string;
+ initiative?: string;
+};
+
+export function usePublicDrafts(filters: PublicDraftFilters) {
+ const [drafts, setDrafts] = useState([]);
+
+ useEffect(() => {
+ setDrafts([]);
+ if (!filters.author && !filters.initiative) {
+ return;
+ }
+ let active = true;
+ const loadAll = async () => {
+ const items: PublicProposalDraftListItemDto[] = [];
+ let cursor: string | undefined;
+ do {
+ const response = await apiPublicProposalDrafts({
+ ...filters,
+ cursor,
+ limit: 100,
+ });
+ items.push(...response.items);
+ cursor = response.nextCursor;
+ } while (cursor && active);
+ if (active) setDrafts(items);
+ };
+ void loadAll().catch(() => {
+ if (active) setDrafts([]);
+ });
+ return () => {
+ active = false;
+ };
+ }, [filters.author, filters.initiative]);
+
+ return drafts;
+}
diff --git a/src/pages/proposals/proposalCreation/ProposalWizardShell.tsx b/src/pages/proposals/proposalCreation/ProposalWizardShell.tsx
index ed0ad54..fbe4098 100644
--- a/src/pages/proposals/proposalCreation/ProposalWizardShell.tsx
+++ b/src/pages/proposals/proposalCreation/ProposalWizardShell.tsx
@@ -234,6 +234,9 @@ type WizardActionsProps = {
continueDisabled?: boolean;
onBack: () => void;
onContinue: () => void;
+ onSecondaryAction?: () => void;
+ secondaryActionDisabled?: boolean;
+ secondaryActionLabel?: string;
submitting: boolean;
};
@@ -244,6 +247,9 @@ export function WizardActions({
continueLabel,
onBack,
onContinue,
+ onSecondaryAction,
+ secondaryActionDisabled = false,
+ secondaryActionLabel,
submitting,
}: WizardActionsProps) {
return (
@@ -256,13 +262,25 @@ export function WizardActions({
>
{backLabel}
-
+
+ {onSecondaryAction && secondaryActionLabel ? (
+
+ ) : null}
+
+
);
}
diff --git a/src/pages/proposals/proposalCreation/publicationReadiness.ts b/src/pages/proposals/proposalCreation/publicationReadiness.ts
new file mode 100644
index 0000000..165debd
--- /dev/null
+++ b/src/pages/proposals/proposalCreation/publicationReadiness.ts
@@ -0,0 +1,15 @@
+import type { ProposalDraftForm, ProposalTemplateId } from "./types";
+import { validateSystemDraftTarget } from "./wizardModel";
+
+export function isProposalDraftPublicationReady(
+ draft: ProposalDraftForm,
+ templateId: ProposalTemplateId,
+): boolean {
+ if (!draft.title.trim() || !draft.summary.trim() || !draft.chamberId.trim()) {
+ return false;
+ }
+ if (templateId === "system") {
+ return validateSystemDraftTarget(draft).valid;
+ }
+ return Boolean(draft.what.trim() && draft.why.trim());
+}
diff --git a/src/pages/proposals/proposalCreation/submitErrorRouting.ts b/src/pages/proposals/proposalCreation/submitErrorRouting.ts
index 2421c9b..f20e126 100644
--- a/src/pages/proposals/proposalCreation/submitErrorRouting.ts
+++ b/src/pages/proposals/proposalCreation/submitErrorRouting.ts
@@ -29,6 +29,14 @@ const scopeCodes = new Set([
"initiative_association_immutable",
]);
+const publicationContentCodes = new Set([
+ "draft_publication_title_required",
+ "draft_publication_summary_required",
+ "draft_publication_chamber_required",
+ "draft_publication_case_required",
+ "draft_publication_rationale_required",
+]);
+
export function proposalSubmitErrorStep(
error: unknown,
pathId: WizardPathId,
@@ -41,6 +49,15 @@ export function proposalSubmitErrorStep(
if (scopeCodes.has(code)) {
return pathId === "system-change" ? "system-change" : "essentials";
}
+ if (publicationContentCodes.has(code)) {
+ return pathId === "system-change" ? "system-change" : "essentials";
+ }
+ if (code === "draft_publication_system_action_required") {
+ return "system-change";
+ }
+ if (code === "draft_publication_invalid_url") {
+ return pathId === "system-change" ? "rationale" : "plan";
+ }
if (code === "draft_not_submittable") {
return firstIncompleteWizardStep(pathId, context);
}
diff --git a/src/pages/proposals/proposalCreation/useProposalDraftHydration.ts b/src/pages/proposals/proposalCreation/useProposalDraftHydration.ts
index 6755f34..96170c9 100644
--- a/src/pages/proposals/proposalCreation/useProposalDraftHydration.ts
+++ b/src/pages/proposals/proposalCreation/useProposalDraftHydration.ts
@@ -4,6 +4,7 @@ import type { NavigateFunction } from "react-router";
import { apiProposalDraft, apiProposalStatus } from "@/lib/apiClient";
import { normalizeSessionDraft } from "./sessionStorage";
import { inferPresetIdFromDraft } from "./presets/registry";
+import type { DraftPublicationSummaryDto } from "@/types/api";
import type { ProposalDraftForm } from "./types";
type ProposalCreationTemplateKind = "project" | "system";
@@ -12,6 +13,7 @@ export type ProposalDraftHydrationResult = {
draft: ProposalDraftForm;
draftId: string;
presetId: string;
+ publication: DraftPublicationSummaryDto;
templateKind: ProposalCreationTemplateKind;
};
@@ -71,6 +73,7 @@ export function useProposalDraftHydration({
draft: normalized,
draftId: nextDraftId,
presetId: nextPresetId,
+ publication: detail.publication,
templateKind: nextTemplateKind,
});
} catch (error) {
diff --git a/src/pages/proposals/proposalCreation/wizardModel.ts b/src/pages/proposals/proposalCreation/wizardModel.ts
index d7dcc5c..5194609 100644
--- a/src/pages/proposals/proposalCreation/wizardModel.ts
+++ b/src/pages/proposals/proposalCreation/wizardModel.ts
@@ -56,6 +56,7 @@ export type StepValidation = {
export type WizardContext = {
draft: ProposalDraftForm;
presetId: string;
+ publicationReady?: boolean;
tierBlocked: boolean;
};
@@ -195,7 +196,9 @@ export function proposalBudgetTotal(draft: ProposalDraftForm): number {
: positiveAmountTotal(draft.budgetItems, (item) => item.amount);
}
-function systemTargetValid(draft: ProposalDraftForm): StepValidation {
+export function validateSystemDraftTarget(
+ draft: ProposalDraftForm,
+): StepValidation {
if (draft.title.trim().length === 0) {
return { valid: false, firstInvalidFieldId: "title" };
}
@@ -254,7 +257,7 @@ export function validateWizardStep(
}
return { valid: true };
}
- if (stepId === "system-change") return systemTargetValid(draft);
+ if (stepId === "system-change") return validateSystemDraftTarget(draft);
if (stepId === "plan" || stepId === "rationale") {
return draft.how.trim().length > 0
? { valid: true }
@@ -289,10 +292,14 @@ export function reachableWizardSteps(
context: WizardContext,
): WizardStepId[] {
const result: WizardStepId[] = [];
- for (const step of WIZARD_PATHS[pathId].steps) {
+ const definition = WIZARD_PATHS[pathId];
+ for (const step of definition.steps) {
result.push(step.id);
if (!validateWizardStep(step.id, context).valid) break;
}
+ if (context.publicationReady && !result.includes("review")) {
+ result.push("review");
+ }
return result;
}
diff --git a/src/types/api.ts b/src/types/api.ts
index bb6e695..c2b4400 100644
--- a/src/types/api.ts
+++ b/src/types/api.ts
@@ -670,9 +670,30 @@ export type ProposalStatusDto = {
| "completed";
pendingMilestoneIndex?: number | null;
initiative?: InitiativeReferenceDto;
+ draftHistory?: {
+ draftId: string;
+ route: string;
+ revision: number;
+ };
updatedAt: string;
};
+export type DraftPublicationStatusDto =
+ | "private"
+ | "published"
+ | "withdrawn"
+ | "submitted";
+
+export type DraftPublicationSummaryDto = {
+ status: DraftPublicationStatusDto;
+ revision?: number;
+ publicUrl?: string;
+ publishedAt?: string;
+ publicUpdatedAt?: string;
+ hasUnpublishedChanges?: boolean;
+ submittedProposalRoute?: string;
+};
+
export type ProposalDraftListItemDto = {
id: string;
title: string;
@@ -680,9 +701,31 @@ export type ProposalDraftListItemDto = {
tier: string;
summary: string;
updated: string;
+ publication: DraftPublicationSummaryDto;
};
export type GetProposalDraftsResponse = { items: ProposalDraftListItemDto[] };
+export type PublicProposalDraftKindDto = "policy" | "formation" | "system";
+export type PublicProposalDraftSortDto = "updated" | "published";
+
+export type PublicProposalDraftListItemDto = {
+ id: string;
+ title: string;
+ chamber: string;
+ summary: string;
+ proposer: string;
+ proposalKind: PublicProposalDraftKindDto;
+ revision: number;
+ publishedAt: string;
+ updatedAt: string;
+ initiative?: InitiativeReferenceDto;
+};
+
+export type GetPublicProposalDraftsResponse = {
+ items: PublicProposalDraftListItemDto[];
+ nextCursor?: string;
+};
+
export type ProposalDraftEditableFormDto = {
templateId?: "project" | "system";
presetId?: string;
@@ -743,7 +786,9 @@ export type ProposalDraftDetailDto = {
teamSlots: string;
milestonesPlanned: string;
summary: string;
+ overview: string;
rationale: string;
+ executionPlan: string[];
budgetScope: string;
checklist: string[];
milestones: string[];
@@ -751,6 +796,9 @@ export type ProposalDraftDetailDto = {
openSlotNeeds: { title: string; desc: string }[];
milestonesDetail: { title: string; desc: string }[];
attachments: { title: string; href?: string }[];
+ authoring: ProposalAuthoringDetailsDto;
+ publication: DraftPublicationSummaryDto;
+ initiative?: InitiativeReferenceDto;
editableForm?: ProposalDraftEditableFormDto;
};
@@ -1103,6 +1151,7 @@ export type HumanNodeDto = {
memberSince: string;
formationCapable?: boolean;
active: {
+ governor: boolean;
governorActive: boolean;
humanNodeActive: boolean;
};
@@ -1161,6 +1210,7 @@ export type HumanDelegationChamberDto = {
export type HumanNodeProfileDto = {
id: string;
name: string;
+ governor: boolean;
governorActive: boolean;
humanNodeActive: boolean;
governanceSummary: string;
diff --git a/src/types/stages.ts b/src/types/stages.ts
index a97e6dc..44b733b 100644
--- a/src/types/stages.ts
+++ b/src/types/stages.ts
@@ -27,9 +27,10 @@ export const feedStages = [
export type FeedStage = (typeof feedStages)[number];
-export type Stage = ProposalStage | FeedStage;
+export type Stage = ProposalStage | FeedStage | "draft";
export type StageChipKind =
+ | "draft"
| "proposal_pool"
| "chamber_vote"
| "citizen_veto"
@@ -44,6 +45,7 @@ export type StageChipKind =
| "system";
export const stageToChipKind = {
+ draft: "draft",
pool: "proposal_pool",
vote: "chamber_vote",
citizen_veto: "citizen_veto",
@@ -59,6 +61,7 @@ export const stageToChipKind = {
} as const satisfies Record;
export const stageLabel = {
+ draft: "Draft",
pool: "Proposal pool",
vote: "Chamber vote",
citizen_veto: "Citizen veto",
diff --git a/tests/e2e/proposal-wizard.spec.ts b/tests/e2e/proposal-wizard.spec.ts
index 3103fb9..d54850d 100644
--- a/tests/e2e/proposal-wizard.spec.ts
+++ b/tests/e2e/proposal-wizard.spec.ts
@@ -38,7 +38,9 @@ function draftDetail(id: string, editableForm: typeof existingDraftForm) {
teamSlots: "0",
milestonesPlanned: "0",
summary: editableForm.summary,
+ overview: editableForm.what,
rationale: editableForm.why,
+ executionPlan: [],
budgetScope: "No Formation budget",
checklist: [],
milestones: [],
@@ -46,6 +48,18 @@ function draftDetail(id: string, editableForm: typeof existingDraftForm) {
openSlotNeeds: [],
milestonesDetail: [],
attachments: [],
+ authoring: {
+ kind: "project",
+ presetId: editableForm.presetId,
+ proposalType: editableForm.proposalType,
+ what: editableForm.what,
+ why: editableForm.why,
+ how: editableForm.how,
+ aboutMe: editableForm.aboutMe,
+ outputs: [],
+ budgetItems: [],
+ },
+ publication: { status: "private" },
editableForm,
};
}
@@ -160,6 +174,7 @@ async function installApiFixtures(page: Page) {
json: {
id: address,
name: "Test Governor",
+ governor: true,
governorActive: true,
humanNodeActive: true,
governanceSummary: "",
@@ -189,6 +204,20 @@ async function installApiFixtures(page: Page) {
});
return;
}
+ if (body.type === "proposal.draft.publish") {
+ await route.fulfill({
+ json: {
+ ok: true,
+ type: body.type,
+ draftId: "draft-e2e",
+ revision: 1,
+ publicUrl: "/app/proposals/public-drafts/draft-e2e",
+ publishedAt: "2026-07-02T12:00:00.000Z",
+ updatedAt: "2026-07-02T12:00:00.000Z",
+ },
+ });
+ return;
+ }
if (body.type === "proposal.submitToPool") {
await route.fulfill({
json: {
@@ -349,6 +378,37 @@ test("fresh entry ignores legacy Review state and completes policy submission",
await expect(page).toHaveURL(/\/app\/proposals\/proposal-e2e\/pp$/);
});
+test("Review publishes an explicit public snapshot without submitting", async ({
+ page,
+}) => {
+ await openFreshWizard(page);
+ await page.locator("#proposal-kind").selectOption("project");
+ await page.locator("#proposal-type").selectOption("basic");
+ await page.locator("#proposal-formation-mode").selectOption("policy");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await page.locator("#title").fill("Draft before governance");
+ await page.locator("#chamber").selectOption("general");
+ await page.locator("#summary").fill("Invite review before submission.");
+ await page.locator("#what").fill("Publish a readable snapshot.");
+ await page.locator("#why").fill("Catch mistakes before formal voting.");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await page.locator("#how").fill("Review, revise, and submit separately.");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await expect(page.locator("#agree-rules")).not.toBeChecked();
+ await expect(page.locator("#confirm-budget")).not.toBeChecked();
+
+ const publishRequest = page.waitForRequest((request) => {
+ if (!request.url().endsWith("/api/command")) return false;
+ return request.postDataJSON()?.type === "proposal.draft.publish";
+ });
+ await page.getByRole("button", { name: "Publish draft" }).click();
+ await publishRequest;
+ await expect(
+ page.getByRole("button", { name: "Update public draft" }),
+ ).toBeVisible();
+ await expect(page).toHaveURL(/step=review/);
+});
+
test("submission locks draft-changing controls until the pool response returns", async ({
page,
}) => {
@@ -561,6 +621,88 @@ test("submission synchronizes the newest edit after an earlier save is still pen
expect(submittedDraftId).toBe("draft-latest-revision");
});
+test("an ambiguous submission failure retries without rewriting the submitted draft", async ({
+ page,
+}) => {
+ let saveCount = 0;
+ const submitKeys: string[] = [];
+
+ await openFreshWizard(page);
+ await page.route("**/api/command", async (route) => {
+ const request = route.request();
+ const body = request.postDataJSON() as { type?: string };
+ if (body.type === "proposal.draft.save") {
+ saveCount += 1;
+ await route.fulfill({
+ json: {
+ ok: true,
+ type: body.type,
+ draftId: "draft-ambiguous-submit",
+ updatedAt: "2026-07-03T12:00:00.000Z",
+ },
+ });
+ return;
+ }
+ if (body.type === "proposal.submitToPool") {
+ submitKeys.push(request.headers()["idempotency-key"] ?? "");
+ if (submitKeys.length === 1) {
+ await route.fulfill({
+ status: 503,
+ json: {
+ error: {
+ code: "temporarily_unavailable",
+ message: "Submission response was interrupted.",
+ },
+ },
+ });
+ return;
+ }
+ await route.fulfill({
+ json: {
+ ok: true,
+ type: body.type,
+ proposalId: "proposal-recovered-submit",
+ },
+ });
+ return;
+ }
+ await route.fallback();
+ });
+
+ await page.locator("#proposal-kind").selectOption("project");
+ await page.locator("#proposal-type").selectOption("basic");
+ await page.locator("#proposal-formation-mode").selectOption("policy");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await page.locator("#title").fill("Recover uncertain submission");
+ await page.locator("#chamber").selectOption("general");
+ await page.locator("#summary").fill("Retry without rewriting the draft.");
+ await page.locator("#what").fill("Preserve an accepted proposal command.");
+ await page
+ .locator("#why")
+ .fill("Network failures cannot reveal commit state.");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await page.locator("#how").fill("Replay the same idempotent submission.");
+ await page.getByRole("button", { name: "Continue" }).click();
+ await page.locator("#agree-rules").check();
+ await page.locator("#confirm-budget").check();
+
+ await page.getByRole("button", { name: "Submit proposal" }).click();
+ await expect(
+ page.getByText("Submission response was interrupted."),
+ ).toBeVisible();
+ expect(saveCount).toBe(1);
+ expect(submitKeys).toHaveLength(1);
+
+ await page.getByRole("button", { name: "Submit proposal" }).click();
+ await expect(page).toHaveURL(
+ /\/app\/proposals\/proposal-recovered-submit\/pp$/,
+ );
+ expect(saveCount).toBe(1);
+ expect(submitKeys).toHaveLength(2);
+ expect(submitKeys[0]).not.toBe("");
+ expect(submitKeys[1]).toBe(submitKeys[0]);
+});
+
test("a keyboard-only author can complete a policy proposal", async ({
page,
}) => {
diff --git a/tests/e2e/public-drafts.spec.ts b/tests/e2e/public-drafts.spec.ts
new file mode 100644
index 0000000..7df2c75
--- /dev/null
+++ b/tests/e2e/public-drafts.spec.ts
@@ -0,0 +1,321 @@
+import { expect, test, type Page } from "@playwright/test";
+
+const draftId = "draft-public-governance";
+const author = "hmr1GRb1SRdDfJZmFaYh5L1RNev3dFcTVLGS2Rqqmk3Fbgj2W";
+
+const listItem = {
+ id: draftId,
+ title: "Transparent governance reporting",
+ chamber: "General Chamber",
+ summary: "Publish regular governance reports before formal submission.",
+ proposer: author,
+ proposalKind: "policy",
+ revision: 2,
+ publishedAt: "2026-07-22T10:00:00.000Z",
+ updatedAt: "2026-07-23T12:30:00.000Z",
+ initiative: {
+ id: "governance-observatory",
+ slug: "governance-observatory",
+ title: "Governance Observatory",
+ },
+};
+
+const detail = {
+ id: draftId,
+ submittedAt: null,
+ submittedProposalId: null,
+ title: listItem.title,
+ proposer: author,
+ chamber: "General Chamber",
+ focus: "Basic",
+ tier: "Consul",
+ budget: "0 HMND",
+ formationEligible: false,
+ teamSlots: "0 / 0",
+ milestonesPlanned: "0",
+ summary: listItem.summary,
+ overview: "Create a public reporting policy with readable evidence.",
+ rationale:
+ "Let reviewers catch mistakes before the proposal enters governance.",
+ executionPlan: [
+ "Publish a signed report at the end of every governance era.",
+ ],
+ budgetScope: "No Formation budget",
+ checklist: [],
+ milestones: [],
+ teamLocked: [],
+ openSlotNeeds: [],
+ milestonesDetail: [],
+ attachments: [],
+ authoring: {
+ kind: "project",
+ presetId: "project.policy",
+ proposalType: "basic",
+ what: "Create a public reporting policy with readable evidence.",
+ why: "Let reviewers catch mistakes before the proposal enters governance.",
+ how: "Publish a signed report at the end of every governance era.",
+ aboutMe: "",
+ outputs: [],
+ timeline: [],
+ budgetItems: [],
+ systemAction: {
+ action: null,
+ chamberId: null,
+ targetAddress: null,
+ title: null,
+ multiplier: null,
+ genesisMembers: [],
+ },
+ },
+ publication: {
+ status: "published",
+ revision: 2,
+ publicUrl: `/app/proposals/public-drafts/${draftId}`,
+ publishedAt: listItem.publishedAt,
+ publicUpdatedAt: listItem.updatedAt,
+ },
+ initiative: listItem.initiative,
+};
+
+async function installFixtures(page: Page) {
+ await page.route("**/api/**", async (route) => {
+ const url = new URL(route.request().url());
+ if (url.pathname === "/api/me") {
+ await route.fulfill({ json: { authenticated: false } });
+ return;
+ }
+ if (url.pathname === "/api/proposals/public-drafts") {
+ await route.fulfill({ json: { items: [listItem] } });
+ return;
+ }
+ if (url.pathname === `/api/proposals/public-drafts/${draftId}`) {
+ await route.fulfill({ json: detail });
+ return;
+ }
+ await route.fulfill({ json: { items: [] } });
+ });
+}
+
+test("anonymous readers can discover and open a complete public draft", async ({
+ page,
+}) => {
+ await installFixtures(page);
+ await page.goto("/app/proposals/public-drafts");
+ await expect(
+ page.getByRole("heading", { name: "Public drafts", exact: true }),
+ ).toBeVisible();
+ await expect(page.getByText(listItem.title, { exact: true })).toBeVisible();
+ await page.getByRole("article").getByRole("button").click();
+ await page.getByRole("link", { name: "Read draft" }).click();
+ await expect(page).toHaveURL(`/app/proposals/public-drafts/${draftId}`);
+ await expect(
+ page.getByRole("heading", { name: listItem.title, exact: true }),
+ ).toBeVisible();
+ await expect(page.getByText("Draft", { exact: true }).first()).toBeVisible();
+ await expect(page.getByText(detail.overview, { exact: true })).toBeVisible();
+ await expect(
+ page.getByRole("button", { name: "Continue editing" }),
+ ).toHaveCount(0);
+});
+
+test("public draft owners receive one coherent action group", async ({
+ page,
+}) => {
+ await page.route("**/api/**", async (route) => {
+ const url = new URL(route.request().url());
+ if (url.pathname === "/api/me") {
+ await route.fulfill({
+ json: {
+ authenticated: true,
+ address: author,
+ gate: {
+ eligible: true,
+ expiresAt: "2026-07-24T20:00:00.000Z",
+ },
+ },
+ });
+ return;
+ }
+ if (url.pathname === `/api/proposals/public-drafts/${draftId}`) {
+ await route.fulfill({ json: detail });
+ return;
+ }
+ await route.fulfill({ json: { items: [] } });
+ });
+
+ await page.goto(`/app/proposals/public-drafts/${draftId}`);
+ await expect(page.getByRole("button", { name: "Copy link" })).toHaveCount(1);
+ await expect(
+ page.getByRole("link", { name: "Continue editing" }),
+ ).toBeVisible();
+ await expect(page.getByRole("button", { name: "Unpublish" })).toBeVisible();
+});
+
+test("changing the directory query retires the previous pagination cursor", async ({
+ page,
+}) => {
+ let mixedCursorRequest = false;
+ await page.route("**/api/**", async (route) => {
+ const url = new URL(route.request().url());
+ if (url.pathname === "/api/me") {
+ await route.fulfill({ json: { authenticated: false } });
+ return;
+ }
+ if (url.pathname === "/api/proposals/public-drafts") {
+ if (url.searchParams.get("q") && url.searchParams.get("cursor")) {
+ mixedCursorRequest = true;
+ }
+ if (url.searchParams.get("q")) {
+ await new Promise((resolve) => setTimeout(resolve, 1_000));
+ }
+ await route.fulfill({
+ json: url.searchParams.get("q")
+ ? { items: [] }
+ : { items: [listItem], nextCursor: "cursor-from-old-query" },
+ });
+ return;
+ }
+ await route.fulfill({ json: { items: [] } });
+ });
+
+ await page.goto("/app/proposals/public-drafts");
+ await expect(page.getByRole("button", { name: "Load more" })).toBeVisible();
+ await page.getByLabel("Search public drafts").fill("different");
+ await page.waitForTimeout(350);
+ expect(await page.getByRole("button", { name: "Load more" }).count()).toBe(0);
+ expect(mixedCursorRequest).toBe(false);
+});
+
+test("My Drafts keeps private and public drafts together and toggles visibility", async ({
+ page,
+}) => {
+ const privateDraft = {
+ id: "owned-private-draft",
+ title: "Private policy notes",
+ chamber: "General Chamber",
+ tier: "Consul",
+ summary: "Notes that are ready to become a public draft.",
+ updated: "2026-07-24T13:00:00.000Z",
+ publication: { status: "private" },
+ };
+ const publicDraft = {
+ id: "owned-public-draft",
+ title: "Published governance outline",
+ chamber: "General Chamber",
+ tier: "Consul",
+ summary: "An owned draft that is already visible publicly.",
+ updated: "2026-07-24T12:00:00.000Z",
+ publication: {
+ status: "published",
+ revision: 2,
+ publicUrl: "/app/proposals/public-drafts/owned-public-draft",
+ publishedAt: "2026-07-23T12:00:00.000Z",
+ publicUpdatedAt: "2026-07-24T12:00:00.000Z",
+ hasUnpublishedChanges: false,
+ },
+ };
+ await page.route("**/api/**", async (route) => {
+ const request = route.request();
+ const url = new URL(request.url());
+ if (url.pathname === "/api/me") {
+ await route.fulfill({
+ json: {
+ authenticated: true,
+ address: author,
+ gate: { eligible: true, expiresAt: "2026-08-01T00:00:00.000Z" },
+ },
+ });
+ return;
+ }
+ if (url.pathname === "/api/proposals/drafts") {
+ await route.fulfill({ json: { items: [privateDraft, publicDraft] } });
+ return;
+ }
+ if (url.pathname.startsWith("/api/humans/")) {
+ await route.fulfill({
+ json: {
+ id: author,
+ name: "Draft Author",
+ humanNodeActive: true,
+ governor: true,
+ governorActive: false,
+ heroStats: [],
+ quickDetails: [],
+ proofSections: {},
+ governanceActions: [],
+ delegation: { chambers: [] },
+ delegationEligibleChambers: [],
+ projects: [],
+ activity: [],
+ history: [],
+ },
+ });
+ return;
+ }
+ if (url.pathname === "/api/command" && request.method() === "POST") {
+ const body = request.postDataJSON() as {
+ type?: string;
+ payload?: { draftId?: string };
+ };
+ if (body.type === "proposal.draft.publish") {
+ await route.fulfill({
+ json: {
+ ok: true,
+ type: body.type,
+ draftId: body.payload?.draftId,
+ revision: 1,
+ publicUrl: `/app/proposals/public-drafts/${body.payload?.draftId}`,
+ publishedAt: "2026-07-24T14:00:00.000Z",
+ updatedAt: "2026-07-24T14:00:00.000Z",
+ },
+ });
+ return;
+ }
+ if (body.type === "proposal.draft.unpublish") {
+ await route.fulfill({
+ json: {
+ ok: true,
+ type: body.type,
+ draftId: body.payload?.draftId,
+ unpublished: true,
+ updatedAt: "2026-07-24T14:05:00.000Z",
+ },
+ });
+ return;
+ }
+ }
+ await route.fulfill({ json: { items: [] } });
+ });
+
+ await page.goto("/app/proposals/drafts");
+ const authPanel = page.locator(".sidebar__auth");
+ const governorRow = authPanel.locator(".sidebar__authRow", {
+ has: page.getByText("Governor", { exact: true }),
+ });
+ const activeGovernorRow = authPanel.locator(".sidebar__authRow", {
+ has: page.getByText("Active governor", { exact: true }),
+ });
+ await expect(governorRow.getByText("Active", { exact: true })).toBeVisible();
+ await expect(
+ activeGovernorRow.getByText("Not active", { exact: true }),
+ ).toBeVisible();
+ await expect(
+ page.getByText(privateDraft.title, { exact: true }),
+ ).toBeVisible();
+ await expect(
+ page.getByText(publicDraft.title, { exact: true }),
+ ).toBeVisible();
+ await page.getByRole("button", { name: "Make draft public" }).click();
+ await expect(
+ page.getByRole("button", { name: "Make draft private" }),
+ ).toHaveCount(2);
+
+ page.once("dialog", (dialog) => void dialog.accept());
+ await page
+ .getByRole("button", { name: "Make draft private" })
+ .first()
+ .click();
+ await expect(
+ page.getByRole("button", { name: "Make draft public" }),
+ ).toHaveCount(1);
+});
diff --git a/tests/unit/human-nodes-ui.test.ts b/tests/unit/human-nodes-ui.test.ts
index 8882204..687af96 100644
--- a/tests/unit/human-nodes-ui.test.ts
+++ b/tests/unit/human-nodes-ui.test.ts
@@ -9,6 +9,7 @@ import {
getHumanNodeManageableDelegationChambers,
getHumanNodeViewerDelegationByChamber,
getHumanNodeVisibleHeroStats,
+ governanceIdentityStatuses,
isLikelyHumanodeAddress,
shouldShowHumanNodeShortBadge,
} from "../../src/lib/humanNodesUi";
@@ -32,6 +33,7 @@ const node = (
mm: 0,
memberSince: "2026-01-01T00:00:00.000Z",
active: {
+ governor: false,
governorActive: false,
humanNodeActive: false,
},
@@ -44,6 +46,7 @@ const profile = (
): HumanNodeProfileDto => ({
id: "hmpt3fxBvpWrkZxq5H5uWjZ2BgHRMJs2hKHiWJDoqD7am1xPs",
name: "Human Node Profile",
+ governor: true,
governorActive: true,
humanNodeActive: true,
governanceSummary: "",
@@ -87,6 +90,24 @@ test("isLikelyHumanodeAddress identifies long hm addresses only", () => {
expect(isLikelyHumanodeAddress("hm-short")).toBe(false);
});
+test("governor and active-governor labels preserve distinct semantics", () => {
+ expect(
+ governanceIdentityStatuses({
+ governor: true,
+ activeGovernor: false,
+ humanNode: true,
+ }),
+ ).toEqual({
+ governor: { label: "Governor", value: "Active", active: true },
+ activeGovernor: {
+ label: "Active governor",
+ value: "Not active",
+ active: false,
+ },
+ humanNode: { label: "Human node", value: "Active", active: true },
+ });
+});
+
test("filterHumanNodes searches chamber and faction names", () => {
const result = filterHumanNodes({
chambersById: {
@@ -122,12 +143,16 @@ test("filterHumanNodes sorts by ACM and honors active status", () => {
},
nodes: [
node("low", {
- active: { governorActive: true, humanNodeActive: true },
+ active: { governor: true, governorActive: true, humanNodeActive: true },
acm: 10,
}),
node("inactive", { acm: 100 }),
node("high", {
- active: { governorActive: true, humanNodeActive: false },
+ active: {
+ governor: true,
+ governorActive: true,
+ humanNodeActive: false,
+ },
cmTotals: { lcm: 0, mcm: 0, acm: 50 },
}),
],
diff --git a/tests/unit/proposal-draft-ui.test.ts b/tests/unit/proposal-draft-ui.test.ts
new file mode 100644
index 0000000..c1ff7c7
--- /dev/null
+++ b/tests/unit/proposal-draft-ui.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, test } from "@rstest/core";
+
+import {
+ canPublishDraft,
+ editDraftRoute,
+ isPublicDraftVisible,
+ ownerDraftRoute,
+ publicationRoute,
+ publicDraftRoute,
+ reconsiderProposalRoute,
+} from "../../src/pages/proposals/draft/draftUi";
+
+describe("proposal draft UI contracts", () => {
+ test("builds encoded owner, editor, public, and reconsideration routes", () => {
+ expect(ownerDraftRoute("draft / one")).toBe(
+ "/app/proposals/drafts/draft%20%2F%20one",
+ );
+ expect(editDraftRoute("draft / one")).toBe(
+ "/app/proposals/new?draftId=draft%20%2F%20one",
+ );
+ expect(publicDraftRoute("draft / one")).toBe(
+ "/app/proposals/public-drafts/draft%20%2F%20one",
+ );
+ expect(reconsiderProposalRoute("proposal / one")).toBe(
+ "/app/proposals/new?resubmitsProposalId=proposal%20%2F%20one",
+ );
+ });
+
+ test("uses server routes and keeps publication states explicit", () => {
+ expect(
+ publicationRoute("draft-1", {
+ status: "published",
+ publicUrl: "/canonical/draft-1",
+ }),
+ ).toBe("/canonical/draft-1");
+ expect(canPublishDraft({ status: "private" })).toBe(true);
+ expect(
+ canPublishDraft({
+ status: "published",
+ hasUnpublishedChanges: false,
+ }),
+ ).toBe(false);
+ expect(isPublicDraftVisible({ status: "submitted" })).toBe(true);
+ expect(isPublicDraftVisible({ status: "withdrawn" })).toBe(false);
+ });
+});
diff --git a/tests/unit/proposal-stage-navigation.test.ts b/tests/unit/proposal-stage-navigation.test.ts
index cabfb77..de1b514 100644
--- a/tests/unit/proposal-stage-navigation.test.ts
+++ b/tests/unit/proposal-stage-navigation.test.ts
@@ -44,3 +44,18 @@ test("proposal stage navigation links terminal live stage and prior formation sn
assert.equal(links.passed, "/app/proposals/p-3/finished");
assert.equal(links.failed, undefined);
});
+
+test("proposal stage navigation exposes Draft only from server-provided history", () => {
+ const withoutHistory = buildProposalStageLinks({
+ liveStage: "vote",
+ proposalId: "p-4",
+ });
+ assert.equal(withoutHistory.draft, undefined);
+
+ const withHistory = buildProposalStageLinks({
+ draftRoute: "/app/proposals/public-drafts/draft-p-4",
+ liveStage: "vote",
+ proposalId: "p-4",
+ });
+ assert.equal(withHistory.draft, "/app/proposals/public-drafts/draft-p-4");
+});
diff --git a/tests/unit/proposal-wizard-model.test.ts b/tests/unit/proposal-wizard-model.test.ts
index 8ef6573..aa8c76c 100644
--- a/tests/unit/proposal-wizard-model.test.ts
+++ b/tests/unit/proposal-wizard-model.test.ts
@@ -16,6 +16,7 @@ import {
validateWizardStep,
type WizardContext,
} from "../../src/pages/proposals/proposalCreation/wizardModel";
+import { isProposalDraftPublicationReady } from "../../src/pages/proposals/proposalCreation/publicationReadiness";
function completePolicyDraft(): ProposalDraftForm {
return {
@@ -79,6 +80,48 @@ test("reachable steps stop after the first invalid requirement", () => {
).toEqual(["intent", "essentials", "plan"]);
});
+test("public review can be reached before the formal submission path is complete", () => {
+ const draft = {
+ ...completePolicyDraft(),
+ chamberId: "general",
+ summary: "Ready for public review",
+ how: "",
+ agreeRules: false,
+ confirmBudget: false,
+ };
+ expect(isProposalDraftPublicationReady(draft, "project")).toBe(true);
+ expect(
+ reachableWizardSteps("project-policy", {
+ ...context(draft),
+ publicationReady: true,
+ }),
+ ).toEqual(["intent", "essentials", "plan", "review"]);
+ expect(validateWizardStep("review", context(draft)).valid).toBe(false);
+});
+
+test("system publication requires the action's canonical target fields", () => {
+ const draft: ProposalDraftForm = {
+ ...completePolicyDraft(),
+ title: "Create a chamber",
+ chamberId: "general",
+ summary: "Open a public system Draft.",
+ metaGovernance: {
+ action: "chamber.create",
+ chamberId: "research",
+ },
+ };
+ expect(isProposalDraftPublicationReady(draft, "system")).toBe(false);
+ expect(
+ isProposalDraftPublicationReady(
+ {
+ ...draft,
+ metaGovernance: { ...draft.metaGovernance!, title: "Research" },
+ },
+ "system",
+ ),
+ ).toBe(true);
+});
+
test("Formation funding validates every milestone budget", () => {
const draft = {
...completePolicyDraft(),
diff --git a/tests/unit/proposal-wizard-submit-routing.test.ts b/tests/unit/proposal-wizard-submit-routing.test.ts
index cec2011..e850245 100644
--- a/tests/unit/proposal-wizard-submit-routing.test.ts
+++ b/tests/unit/proposal-wizard-submit-routing.test.ts
@@ -59,3 +59,20 @@ test("incomplete server drafts resolve to the first incomplete local step", () =
),
).toBe("plan");
});
+
+test("publication validation returns to the path-owned content step", () => {
+ expect(
+ proposalSubmitErrorStep(
+ apiError("draft_publication_summary_required"),
+ "project-policy",
+ context,
+ ),
+ ).toBe("essentials");
+ expect(
+ proposalSubmitErrorStep(
+ apiError("draft_publication_system_action_required"),
+ "system-change",
+ context,
+ ),
+ ).toBe("system-change");
+});