Evidence
“The venue moved the summit from 12 September to 26 September.”
Source text preserved
Work & Productivity · Build Week
Control project change without the chain reaction.
InOrdo turns an unstructured update into evidence-backed changes, traces the work they affect, and keeps people in control before anything is applied.
Current state
Protected review workspace connected
The authenticated UI uses the existing analysis, impact, apply, history, and undo contracts. Live results remain environment- and backend-state dependent; synthetic previews stay labeled.
Illustrative trace · not connected
Venue date change
& {
readonly [requestScopedClientCapability]: "request-scoped";
};
type CreateServerSupabaseClientOptions = {
/** Route Handlers must apply this same Headers object to their response. */
responseHeaders?: Headers;
};
export async function createServerSupabaseClient(
options: CreateServerSupabaseClientOptions = {},
): Promise {
const env = getPublicEnv();
const cookieStore = await cookies();
return createServerClient(
env.NEXT_PUBLIC_SUPABASE_URL,
env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
{
cookies: {
getAll: () => cookieStore.getAll(),
setAll(cookiesToSet, responseHeaders) {
for (const [name, value] of Object.entries(responseHeaders)) {
options.responseHeaders?.set(name, value);
}
try {
for (const { name, value, options } of cookiesToSet) {
cookieStore.set(name, value, options);
}
} catch {
// Server Components cannot set response cookies. The request proxy
// refreshes them; Server Actions can write through this same client.
}
},
},
},
) as ServerSupabaseClient;
}
```
### src/app/app/layout.tsx
```typescript
import Link from "next/link";
import { redirect } from "next/navigation";
import { LogOut } from "lucide-react";
import { logoutAction } from "@/app/login/actions";
import { ProjectNavigation } from "@/app/app/project-navigation";
import { AuthorizationError } from "@/lib/auth/errors";
import { requireUser, type AuthenticatedUser } from "@/lib/auth/guards";
import { createServerSupabaseClient } from "@/lib/supabase/server";
export const dynamic = "force-dynamic";
export default async function ProtectedAppLayout({
children,
}: Readonly<{ children: React.ReactNode }>) {
let user: AuthenticatedUser | null = null;
let authenticationRequired = false;
try {
const client = await createServerSupabaseClient();
user = await requireUser(client);
} catch (error) {
if (
error instanceof AuthorizationError &&
error.code === "unauthenticated"
) {
authenticationRequired = true;
} else {
throw error;
}
}
if (authenticationRequired || !user) {
redirect("/login?next=/app");
}
return (
{children}
);
}
```
### src/app/login/page.tsx
```typescript
import type { Metadata } from "next";
import Link from "next/link";
import { LockKeyhole, ShieldCheck } from "lucide-react";
import { LoginForm } from "@/app/login/login-form";
import { getSafeRedirect } from "@/lib/auth/redirect";
export const metadata: Metadata = {
title: "Sign in · InOrdo",
description: "Sign in to the isolated InOrdo demonstration workspace.",
};
type LoginPageProps = {
searchParams: Promise<{ next?: string | string[] }>;
};
export default async function LoginPage({ searchParams }: LoginPageProps) {
const query = await searchParams;
const requestedNext = Array.isArray(query.next) ? query.next[0] : query.next;
const nextPath = getSafeRedirect(requestedNext);
return (
);
}
```
### src/lib/env/server.ts
```typescript
import "server-only";
import { z } from "zod";
import {
analysisModes,
type AnalysisProviderPolicy,
type GatewayModel,
type RecordingModel,
} from "@/features/analysis/provider-policy";
import {
EnvironmentConfigurationError,
exactNonBlankEnvironmentValueSchema,
publicEnvSchema,
} from "@/lib/env/public";
const openAIModelSchema = z
.string()
.trim()
.min(1)
.default("gpt-5.6-luna");
export const applicationEnvSchema = publicEnvSchema.extend({
SUPABASE_SERVICE_ROLE_KEY: exactNonBlankEnvironmentValueSchema,
DEMO_PROJECT_SLUG: exactNonBlankEnvironmentValueSchema,
DEMO_RESET_SECRET: exactNonBlankEnvironmentValueSchema,
});
export const serverEnvSchema = applicationEnvSchema.extend({
OPENAI_API_KEY: exactNonBlankEnvironmentValueSchema,
OPENAI_MODEL: openAIModelSchema,
});
const privilegedEnvSchema = z.object({
NEXT_PUBLIC_SUPABASE_URL: publicEnvSchema.shape.NEXT_PUBLIC_SUPABASE_URL,
SUPABASE_SERVICE_ROLE_KEY: exactNonBlankEnvironmentValueSchema,
});
const demoEnvSchema = z.object({
DEMO_PROJECT_SLUG: exactNonBlankEnvironmentValueSchema,
});
const demoResetEnvSchema = demoEnvSchema.extend({
DEMO_RESET_SECRET: exactNonBlankEnvironmentValueSchema,
});
export const openAIEnvSchema = z.object({
OPENAI_API_KEY: exactNonBlankEnvironmentValueSchema,
OPENAI_MODEL: openAIModelSchema,
});
const openAIModelEnvSchema = openAIEnvSchema.pick({ OPENAI_MODEL: true });
const recordingModelName: RecordingModel = "gpt-5.6-luna";
const gatewayModelName: GatewayModel = "openai/gpt-oss-20b";
const gatewayBaseURL = "https://ai-gateway.vercel.sh/v1" as const;
const analysisRuntimeValuesSchema = z.object({
ANALYSIS_MODE: z.string().optional(),
AI_GATEWAY_API_KEY: z.string().optional(),
AI_GATEWAY_MODEL: z.string().optional(),
OPENAI_API_KEY: z.string().optional(),
OPENAI_MODEL: z.string().optional(),
});
export type AnalysisRuntimeEnv =
| {
mode: "disabled";
policy: AnalysisProviderPolicy;
credential: null;
}
| {
mode: "recording";
policy: AnalysisProviderPolicy;
credential: { apiKey: string; model: RecordingModel } | null;
}
| {
mode: "auto";
policy: AnalysisProviderPolicy;
credential: {
apiKey: string;
model: GatewayModel;
baseURL: typeof gatewayBaseURL;
} | null;
};
function baseAnalysisPolicy(
mode: AnalysisProviderPolicy["mode"],
): AnalysisProviderPolicy {
return {
mode,
recordingReady: false,
gatewayReady: false,
recordingModelName,
gatewayModelName,
};
}
export function parseAnalysisRuntimeEnv(values: unknown): AnalysisRuntimeEnv {
const parsed = analysisRuntimeValuesSchema.safeParse(values);
const parsedMode = parsed.success
? z.enum(analysisModes).safeParse(parsed.data.ANALYSIS_MODE)
: null;
if (!parsedMode?.success || !parsed.success) {
return {
mode: "disabled",
policy: baseAnalysisPolicy("disabled"),
credential: null,
};
}
const mode = parsedMode.data;
if (mode === "recording") {
const apiKey = exactNonBlankEnvironmentValueSchema.safeParse(
parsed.data.OPENAI_API_KEY,
);
const configuredModel = parsed.data.OPENAI_MODEL ?? recordingModelName;
const ready = apiKey.success && configuredModel === recordingModelName;
return {
mode,
policy: {
...baseAnalysisPolicy(mode),
recordingReady: ready,
},
credential: ready
? { apiKey: apiKey.data, model: recordingModelName }
: null,
};
}
if (mode === "auto") {
const apiKey = exactNonBlankEnvironmentValueSchema.safeParse(
parsed.data.AI_GATEWAY_API_KEY,
);
const ready =
apiKey.success && parsed.data.AI_GATEWAY_MODEL === gatewayModelName;
return {
mode,
policy: {
...baseAnalysisPolicy(mode),
gatewayReady: ready,
},
credential: ready
? {
apiKey: apiKey.data,
model: gatewayModelName,
baseURL: gatewayBaseURL,
}
: null,
};
}
return {
mode: "disabled",
policy: baseAnalysisPolicy("disabled"),
credential: null,
};
}
export function getAnalysisRuntimeEnv(): AnalysisRuntimeEnv {
return parseAnalysisRuntimeEnv({
ANALYSIS_MODE: process.env.ANALYSIS_MODE,
AI_GATEWAY_API_KEY: process.env.AI_GATEWAY_API_KEY,
AI_GATEWAY_MODEL: process.env.AI_GATEWAY_MODEL,
OPENAI_API_KEY: process.env.OPENAI_API_KEY,
OPENAI_MODEL: process.env.OPENAI_MODEL,
});
}
function parseEnvironment(
scope: string,
schema: T,
values: unknown,
): z.infer {
const result = schema.safeParse(values);
if (!result.success) {
throw new EnvironmentConfigurationError(scope, result.error.issues);
}
return result.data;
}
export function getServerEnv(): z.infer {
return parseEnvironment("Server", serverEnvSchema, {
NEXT_PUBLIC_SUPABASE_URL: process.env.NEXT_PUBLIC_SUPABASE_URL,
NEXT_PUBLIC_SUPABASE_ANON_KEY:
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
SUPABASE_SERVICE_ROLE_KEY: process.env.SUPABASE_SERVICE_ROLE_KEY,
OPENAI_API_KEY: process.env.OPENAI_API_KEY,
OPENAI_MODEL: process.env.OPENAI_MODEL,
DEMO_PROJECT_SLUG: process.env.DEMO_PROJECT_SLUG,
DEMO_RESET_SECRET: process.env.DEMO_RESET_SECRET,
});
}
export function getPrivilegedSupabaseEnv() {
return parseEnvironment("Privileged Supabase", privilegedEnvSchema, {
NEXT_PUBLIC_SUPABASE_URL: process.env.NEXT_PUBLIC_SUPABASE_URL,
SUPABASE_SERVICE_ROLE_KEY: process.env.SUPABASE_SERVICE_ROLE_KEY,
});
}
export function getDemoProjectSlug(): string {
return parseEnvironment("Demo project", demoEnvSchema, {
DEMO_PROJECT_SLUG: process.env.DEMO_PROJECT_SLUG,
}).DEMO_PROJECT_SLUG;
}
export function parseDemoResetEnv(values: unknown) {
return parseEnvironment("Demo reset", demoResetEnvSchema, values);
}
export function getDemoResetEnv(): z.infer>;
};
const uuidPattern =
/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
function formatDate(value: string | null) {
return value ? format(parseISO(value), "MMM d, yyyy") : "Not scheduled";
}
function words(value: string) {
return value.replaceAll("_", " ");
}
export default async function DemoWorkspacePage({
searchParams,
}: DemoWorkspacePageProps) {
const analysisAvailability = buildAnalysisAvailability(
getAnalysisRuntimeEnv().policy,
);
const query = await searchParams;
const requestedAnalysisId =
typeof query.analysisRequestId === "string" &&
uuidPattern.test(query.analysisRequestId)
? query.analysisRequestId
: undefined;
let loadError: unknown;
let result:
| {
overview: Awaited>;
items: Awaited>;
workflow: Awaited>;
dependencies: Awaited<
ReturnType<
ReturnType["listDependencies"]
>
>;
role: WorkspaceRole;
}
| undefined;
try {
const client = await createServerSupabaseClient();
const user = await requireUser(client);
const demoProject = await getDemoWorkspaceProject(client);
const scope = await requireProjectToWorkspace(
client,
user.id,
demoProject.workspace_id,
demoProject.id,
);
const projectRecords = createProjectRecordOperations({ client });
const [overview, items, workflow, dependencies] =
await Promise.all([
getProjectOverview(client, scope),
listProjectItems(client, scope),
getImpactWorkflowData(client, scope, {
analysisRequestId: requestedAnalysisId,
}),
projectRecords.listDependencies(scope.projectId),
]);
result = {
overview,
items,
workflow,
dependencies,
role: scope.membership.role,
};
} catch (error) {
loadError = error;
}
if (loadError instanceof AuthorizationError) {
if (loadError.code === "unauthenticated") redirect("/login?next=/app");
if (loadError.code === "not_found") notFound();
}
if (loadError) throw loadError;
if (!result) throw new Error("The project overview could not be loaded.");
const {
dependencies,
items,
overview,
role,
workflow,
} = result;
const workspace = overview.project.workspace;
const eventItem = items.data.find((item) => item.item_type === "event");
const upcomingMilestones = items.data
.filter(
(item) =>
item.item_type === "milestone" &&
!["completed", "cancelled"].includes(item.status),
)
.sort((left, right) =>
(left.due_date ?? "9999-12-31").localeCompare(
right.due_date ?? "9999-12-31",
),
)
.slice(0, 3);
const openRisksAndBlockers = items.data.filter(
(item) =>
(item.item_type === "risk" || item.status === "blocked") &&
!["completed", "cancelled"].includes(item.status),
);
const team = [
...new Map(
items.data.flatMap((item) =>
item.owner
? [[item.owner.id, item.owner] as const]
: [],
),
).values(),
].sort((left, right) => left.display_name.localeCompare(right.display_name));
const latestSource = workflow.analysis?.source;
const workflowOverview = buildWorkflowOverview({
analysisLoadFailed: workflow.analysisLoadFailed,
operationsLoadFailed: workflow.operationsLoadFailed,
impactCount: workflow.analysis?.impacts.length ?? 0,
hasProposal: Boolean(workflow.analysis?.proposal),
operationCount: workflow.operations.length,
});
const summaryCards = [
{ label: "Project items", value: overview.counts.items, icon: ListChecks },
{ label: "Dependencies", value: dependencies.length, icon: GitBranch },
{
label: "Risks / blockers",
value: openRisksAndBlockers.length,
icon: ShieldAlert,
},
{ label: "Evidence updates", value: overview.counts.sources, icon: FileText },
] as const;
const quickLinks = [
{
href: "/app/items",
label: "Items",
detail: `${items.total} canonical records`,
},
{
href: "/app/dependencies",
label: "Dependencies",
detail: `${dependencies.length} explicit relationships`,
},
{
href: "#impact-status",
label: "Impacts",
detail: workflowOverview.impactDetail,
},
{
href: "#history-status",
label: "History",
detail: workflowOverview.historyDetail,
},
] as const;
return (
InOrdo
Synthetic
Synthetic demo
Authenticated session
IO
Isolated demo access
Review real seeded project data.
Authentication and row-level security protect this preview. The signed-in workspace keeps source evidence, model inference, deterministic impact paths, human approval, and reversible operations separately attributable.
The demo password is provisioned outside source control.
Authentication
Sign in
Need access? Ask the demo operator to provision an account. No public sign-up is enabled.
Return to the landing page