@@ -0,0 +1,18 @@
+---
+'@object-ui/plugin-detail': patch
+---
+
+fix(plugin-detail): `record:path` leaves out a stage the record's status option rules out, instead of ticking it
+
+Clause-②: no
+Metadata-protocol: none
+Ruling-ref: #26581 ruling `6442747364` letter A, with its guardrail
+
+A path ticked every stage before the current one by position, so a stage the record could never have stood on read as passed: an order contract that skips legal review by type showed 「审查中 ✓」 after approval. The status field's option already says which records it applies to. Its `visibleWhen` means "offered only when TRUE (else omitted)", and the server refuses a write of a value whose predicate is false. So `record:path` now omits, on both the desktop and the mobile row, any stage whose matching option declares a `visibleWhen` that is FALSE for the record.
+
+- Stages match options by value, so authored `stages[]` are filtered the same way as stages derived from the picklist.
+- A predicate that reads the acting user (`current_user`, `user`, `ctx` or `os`) hides nothing. It says who may pick the value, not which route the record takes.
+- A predicate that cannot be evaluated keeps its stage, as an option list keeps an option (render side fail-open, ADR-0137 D3).
+- The stage the record stands on is always drawn.
+
+No new key and no new read: the predicate is evaluated against the record and object definition the record page already holds.
@@ -0,0 +1,189 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * ══════════════════════════════════════════════════════════════════════════
+ * A stage the record's own columns rule out is not drawn (objectstack#26581)
+ * ══════════════════════════════════════════════════════════════════════════
+ *
+ * hotclm's order contracts skip legal review by type, yet their path drew
+ * 草稿 ✓ 已提交 ✓ 审查中 ✓ 审批中 ✓ 已批准: every stage before the current one
+ * ticks by position. The status option already says which records it applies
+ * to — `visibleWhen`, "offered only when TRUE (else omitted)", refused on write
+ * by the server when false — so `record:path` omits a stage whose option's
+ * predicate is FALSE for the record. Ruling 6442747364, letter A with its
+ * guardrail.
+ *
+ * Rows:
+ *   (a) the card's contract: an ORD contract's path omits 审查中 on both rows;
+ *       CONTROL, a type the rule admits keeps it;
+ *   (b) a predicate that reads the acting user hides nothing, even where its
+ *       record half alone is FALSE;
+ *   (c) a predicate that cannot be evaluated keeps its stage (fail-open);
+ *   (d) the stage the record stands on is kept even when its rule is FALSE;
+ *   (e) authored `stages[]` are matched to the options by value;
+ *   (f) a quoted `'user'` is a literal, not the acting user.
+ *
+ * Resolution: `../../index` is this package's own source, and
+ * `@object-ui/react` / `@object-ui/core` / `@object-ui/i18n` map to their `src`
+ * through the root `vitest.config.mts` alias table, so no `dist/` sits between
+ * this file and the renderer.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import '@testing-library/jest-dom';
+import { render, cleanup, within, type RenderResult } from '@testing-library/react';
+import { I18nProvider } from '@object-ui/i18n';
+import { RecordContextProvider, SchemaRenderer } from '@object-ui/react';
+// Registers `record:path`, the block under test.
+import '../../index';
+
+const OBJECT_NAME = 'clm_contract';
+
+const NOT_ORD = "record.contract_type != 'ORD'";
+
+const contractDef = (reviewGate: string | undefined) => ({
+  name: OBJECT_NAME,
+  label: 'Contract',
+  fields: {
+    contract_type: { name: 'contract_type', label: 'Type', type: 'text' },
+    status: {
+      name: 'status',
+      label: 'Status',
+      type: 'select',
+      options: [
+        { value: 'draft', label: '草稿' },
+        { value: 'submitted', label: '已提交' },
+        { value: 'in_review', label: '审查中', ...(reviewGate !== undefined ? { visibleWhen: reviewGate } : {}) },
+        { value: 'in_approval', label: '审批中' },
+        { value: 'approved', label: '已批准' },
+      ],
+    },
+  },
+});
+
+const doc = (properties: Record<string, unknown>) => ({ type: 'record:path', properties });
+
+function mount(node: unknown, objectSchema: unknown, data: Record<string, unknown>): RenderResult {
+  return render(
+    <I18nProvider config={{ defaultLanguage: 'zh', detectBrowserLanguage: false }}>
+      <RecordContextProvider
+        objectName={OBJECT_NAME}
+        recordId="c1"
+        data={{ id: 'c1', ...data }}
+        objectSchema={objectSchema as never}
+      >
+        <SchemaRenderer schema={node as never} />
+      </RecordContextProvider>
+    </I18nProvider>,
+  );
+}
+
+/** Both rows (desktop and mobile), in DOM order. */
+function rowsOf(r: RenderResult): [HTMLElement, HTMLElement] {
+  const text = r.container.textContent ?? '';
+  expect(text).not.toContain('failed to render');
+  expect(text).not.toContain('no stages configured');
+  const rows = Array.from(r.container.querySelectorAll('[role="list"]')) as HTMLElement[];
+  expect(rows).toHaveLength(2);
+  return [rows[0], rows[1]];
+}
+
+const stagesOf = (row: HTMLElement): HTMLElement[] => within(row).getAllByRole('listitem');
+const textOf = (stage: HTMLElement): string => (stage.textContent ?? '').replace(/[✓✗]/g, '').trim();
+/** `label:state` per stage, so one assertion pins what is drawn AND how. */
+const pathOf = (row: HTMLElement): string[] =>
+  stagesOf(row).map((s) => `${textOf(s)}:${s.getAttribute('data-stage-state')}`);
+
+const ORD_APPROVED_PATH = ['草稿:completed', '已提交:completed', '审批中:completed', '已批准:current'];
+const FULL_APPROVED_PATH = ['草稿:completed', '已提交:completed', '审查中:completed', '审批中:completed', '已批准:current'];
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe('(a) a stage the option rules out for this record is not drawn (objectstack#26581)', () => {
+  it('an ORD contract that was approved: 审查中 is omitted on both rows, not ticked', () => {
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef(NOT_ORD), { contract_type: 'ORD', status: 'approved' }),
+    );
+    expect(pathOf(desktop)).toEqual(ORD_APPROVED_PATH);
+    expect(pathOf(mobile)).toEqual(ORD_APPROVED_PATH);
+  });
+
+  it('CONTROL: a contract type the rule admits keeps 审查中 as a passed stage', () => {
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef(NOT_ORD), { contract_type: 'SVC', status: 'approved' }),
+    );
+    expect(pathOf(desktop)).toEqual(FULL_APPROVED_PATH);
+    expect(pathOf(mobile)).toEqual(FULL_APPROVED_PATH);
+  });
+});
+
+describe('(b) a predicate that reads the acting user hides nothing', () => {
+  it("FALSE on its record half alone, it still keeps 审查中: it says who may pick, not the record's route", () => {
+    const gate = `${NOT_ORD} && 'legal' in current_user.positions`;
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef(gate), { contract_type: 'ORD', status: 'approved' }),
+    );
+    expect(pathOf(desktop)).toEqual(FULL_APPROVED_PATH);
+    expect(pathOf(mobile)).toEqual(FULL_APPROVED_PATH);
+  });
+});
+
+describe('(c) a predicate that cannot be evaluated keeps its stage (render fail-open, ADR-0137 D3)', () => {
+  it('a predicate that does not parse leaves 审查中 drawn', () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef('record.contract_type !='), {
+        contract_type: 'ORD',
+        status: 'approved',
+      }),
+    );
+    expect(pathOf(desktop)).toEqual(FULL_APPROVED_PATH);
+    expect(pathOf(mobile)).toEqual(FULL_APPROVED_PATH);
+  });
+});
+
+describe('(d) the stage the record stands on is always drawn', () => {
+  it('an ORD contract standing on 审查中 shows it as current, though its rule is FALSE now', () => {
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef(NOT_ORD), { contract_type: 'ORD', status: 'in_review' }),
+    );
+    const expected = ['草稿:completed', '已提交:completed', '审查中:current', '审批中:upcoming', '已批准:upcoming'];
+    expect(pathOf(desktop)).toEqual(expected);
+    expect(pathOf(mobile)).toEqual(expected);
+  });
+});
+
+describe('(e) authored stages are matched to the status options by value', () => {
+  it('an authored 审查中 stage is omitted for an ORD contract, as the derived one is', () => {
+    const stages = [
+      { value: 'draft', label: 'Draft' },
+      { value: 'in_review', label: 'Legal review' },
+      { value: 'approved', label: 'Approved' },
+    ];
+    const [desktop, mobile] = rowsOf(
+      mount(doc({ statusField: 'status', stages }), contractDef(NOT_ORD), { contract_type: 'ORD', status: 'approved' }),
+    );
+    expect(stagesOf(desktop).map(textOf)).toEqual(['Draft', 'Approved']);
+    expect(stagesOf(mobile).map(textOf)).toEqual(['Draft', 'Approved']);
+  });
+});
+
+describe("(f) a quoted 'user' is a literal, not the acting user", () => {
+  it('a record-only predicate comparing against the string "user" still hides its stage', () => {
+    const [desktop] = rowsOf(
+      mount(doc({ statusField: 'status' }), contractDef("record.contract_type != 'user'"), {
+        contract_type: 'user',
+        status: 'approved',
+      }),
+    );
+    expect(stagesOf(desktop).map(textOf)).toEqual(['草稿', '已提交', '审批中', '已批准']);
+  });
+});
@@ -12,7 +12,9 @@
  * stages render as upcoming.
  *
  * When `stages` is absent, the stages come from `statusField`'s picklist on
- * the record's object (objectui#11106) — see the `rawStages` read below.
+ * the record's object (objectui#11106) — see the `rawStages` read below. A
+ * stage whose option's `visibleWhen` rules this record out is not drawn at all
+ * (objectstack#26581) — see `stagesThisRecordWalks`.
  *
  * ── This surface is a READOUT, and it must look like one (objectui#5768) ──
  *
@@ -60,6 +62,7 @@ import { useRecordContext, useSafeFieldLabel } from '@object-ui/react';
 import { useObjectTranslation, pickLocalized } from '@object-ui/i18n';
 import type { RecordPathComponentProps } from '@object-ui/types';
 import { cn } from '@object-ui/components';
+import { evalFieldPredicate, type FieldRulePredicate } from '@object-ui/core';
 import { useDetailTranslation } from '../useDetailTranslation';
 import { declaredStageKinds, deriveStages, stageTerminalOfKind } from '../synth/buildDefaultPageSchema';
 import { useRecordAriaProps } from './recordComponentAria';
@@ -146,6 +149,70 @@ function localizeStageLabels(stages: unknown, language: string): PathStage[] {
   return out ?? (stages as PathStage[]);
 }
 
+/**
+ * The roots that name the ACTING USER, the list the server's option gate reads
+ * a predicate's roots against (`USER_SCOPE_ROOTS`, objectql
+ * `validation/rule-validator.ts`).
+ */
+const ACTING_USER_ROOT = /(^|[^.\w$])(current_user|user|ctx|os)(?![\w$])/;
+
+/**
+ * Does this predicate read the acting user? Read off the source with its
+ * string literals blanked, so a quoted `'user'` never counts. Its only error
+ * is an over-match, and an over-match keeps a stage, never hides one.
+ */
+function readsActingUser(pred: FieldRulePredicate): boolean {
+  const source = typeof pred === 'string' ? pred : typeof pred?.source === 'string' ? pred.source : '';
+  return ACTING_USER_ROOT.test(source.replace(/'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, "''"));
+}
+
+/**
+ * The stages THIS record can walk (objectstack#26581): every stage, less those
+ * whose status-field option declares a `visibleWhen` that is FALSE for the
+ * record.
+ *
+ * The path used to show every option, so a stage the record's own columns rule
+ * out read as passed once the record was beyond it: hotclm's order contracts
+ * skip legal review by type, and their path ticked 「审查中 ✓」 anyway. The
+ * option already says which records it applies to: `visibleWhen` is "offered
+ * only when TRUE (else omitted)" (`SelectOptionSchema`, spec `data/field.zod.ts`),
+ * and the server refuses a write of a value whose predicate is false, so the
+ * record could not have stood on such a stage. Ruling: objectstack#26581
+ * comment 6442747364, letter A with its guardrail.
+ *
+ *   • Stages match options by VALUE, as `declaredStageKinds` reads `kind`, so
+ *     authored `stages[]` are filtered too.
+ *   • A predicate that reads the acting user hides nothing: it answers "who may
+ *     pick this value", not "does this record walk this stage".
+ *   • A predicate that cannot be evaluated keeps its stage: the render side
+ *     stays fail-open (ADR-0137 D3), as an option list does.
+ *   • The stage the record stands on is always kept: it is where the record is.
+ *
+ * No read is added: the record and its object definition are the ones the
+ * record context already holds.
+ */
+function stagesThisRecordWalks(
+  stages: PathStage[],
+  options: unknown,
+  record: Record<string, unknown> | undefined,
+  current: unknown,
+): PathStage[] {
+  if (!record || !Array.isArray(options)) return stages;
+  const gates = new Map<unknown, FieldRulePredicate>();
+  for (const o of options) {
+    if (o?.visibleWhen != null && !readsActingUser(o.visibleWhen)) gates.set(o.value, o.visibleWhen);
+  }
+  if (gates.size === 0) return stages;
+  const kept = stages.filter((s) => {
+    const gate = gates.get(s.value);
+    if (gate === undefined || s.value === current) return true;
+    return evalFieldPredicate(gate, record, true, undefined, undefined, {
+      context: `record:path stage '${String(s.value)}' (option visibleWhen)`,
+    });
+  });
+  return kept.length === stages.length ? stages : kept;
+}
+
 export interface RecordPathRendererProps {
   schema?: RecordPathComponentProps & Record<string, any>;
   className?: string;
@@ -238,7 +305,7 @@ export const RecordPathRenderer: React.FC<RecordPathRendererProps> = ({
   // record context knows which object owns the field. Falls back to the
   // schema's own labels (already English in synth, possibly authored in
   // any language for full Lightning pages) when no translation is found.
-  const stages: PathStage[] = React.useMemo(() => {
+  const localizedStages: PathStage[] = React.useMemo(() => {
     if (rawStages.length === 0 || !statusField || !ctx?.objectName) return rawStages;
     const translated = translateOptions(ctx.objectName, statusField, rawStages as any);
     if (Array.isArray(translated) && translated.length === rawStages.length) {
@@ -247,6 +314,13 @@ export const RecordPathRenderer: React.FC<RecordPathRendererProps> = ({
     return rawStages;
   }, [rawStages, statusField, ctx?.objectName, translateOptions]);
   const current = statusField && ctx?.data ? (ctx.data as any)[statusField] : undefined;
+  // Less the stages this record's own columns rule out (objectstack#26581) —
+  // see `stagesThisRecordWalks`. Both rows below read this one list.
+  const statusOptions = statusField ? (objectSchema as any)?.fields?.[statusField]?.options : undefined;
+  const stages: PathStage[] = React.useMemo(
+    () => stagesThisRecordWalks(localizedStages, statusOptions, ctx?.data as Record<string, unknown> | undefined, current),
+    [localizedStages, statusOptions, ctx?.data, current],
+  );
 
   // The lifecycle `kind` the status field's options declare (objectui#12907),
   // read off the same `objectSchema` the derivation above reads.