diff --git a/README.md b/README.md
index 17b2168..c97f16c 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
 | ----------------------------------------- | ---------------------------------------------------- | ----- |
 | [Token 任务炼金炉](./labs/token-forge/)   | 把闲置 Token、仓库上下文和目标转换为可验收的开发任务 | Alpha |
 | [AI 故障侦探](./labs/incident-detective/) | 在合成事故中练习按证据排障，而不是让 AI 猜根因       | Alpha |
-| [SMART / RMA 报告机](./labs/smart-rma/)   | 本地解析硬盘信息，分离工具状态、关键指标与未知项     | Alpha |
+| [SMART / RMA 报告机](./labs/smart-rma/)   | 本地解析并遮蔽硬盘标识，分离关键指标与未知项         | Alpha |
 
 ## 产品原则
 
@@ -58,6 +58,7 @@ Web 端采用 **Astro + TypeScript + Preact Islands**，首期生成静态 HTML
 - Incident Detective 分享卡：遵循 [Score-only 隐私 SVG](./docs/incident-detective-share-card.md)。
 - SMART / RMA 合成输入：遵循 [完全合成 Fixture 合同](./docs/smart-rma-synthetic-fixtures.md)。
 - SMART / RMA 浏览器解析：遵循 [Parse Result v1 与失败边界](./docs/smart-rma-parser-v1.md)。
+- SMART / RMA 本地脱敏：遵循 [预览、Boundary Projection 与 sink 边界](./docs/smart-rma-redaction-v1.md)。
 - 处理用户输入：先读 [隐私模型](./docs/privacy-model.md) 和 [脱敏包](./packages/redaction/README.md)。
 - 发布站点：遵循 [Cloudflare Workers 部署](./docs/cloudflare-deployment.md)。
 
@@ -91,5 +92,6 @@ Attempt v1。P2-004 已加入五维 100 分确定性评分、逐条判定和改
 Score-only 的确定性 SVG 下载，Incident Detective MVP 六个任务全部闭环。P3-001 已建立
 7 份完全合成的 ATA、NVMe 与未知协议 `smartctl` 输入及版本化索引，覆盖健康、预警、危险、
 缺失字段、厂商扩展、SMART 不可用和冲突信号。P3-002 已上线浏览器端只读解析工作台和
-Parse Result v1：原文只在当前页面内存中处理，输出排除原文与设备标识，且明确不做健康或
-保修判断；下一步是 P3-003 完整输入脱敏。
+Parse Result v1。P3-003 已增加序列号、WWN、主机名、IP 与常见 Secret 的本地脱敏预览，
+以及不含自由文本的 Boundary Projection v1；URL、日志和 Analytics 进一步收窄为固定元数据，
+AI 与导出尚未启用。下一步是 P3-004 确定性健康分类，现有结果仍不构成厂商保修判断。
diff --git a/TODO.md b/TODO.md
index 7c6c998..00ce714 100644
--- a/TODO.md
+++ b/TODO.md
@@ -101,7 +101,12 @@
   - 验收：结构化提取版本、协议、设备类别、SMART 支持、工具报告状态、ATA/NVMe 指标、稳定
     信号和缺失字段；64 KiB 上限与错误失败关闭；不上传、持久化或回显原文和设备标识；不做
     健康分类、AI 解释或保修判断。
-- [ ] **P3-003 [M] 实现序列号、WWN、主机名和 IP 脱敏**
+- [x] **P3-003 [M] 实现序列号、WWN、主机名和 IP 脱敏**
+  - 产物：smartctl 标识格式扩展、本地脱敏预览、Boundary Projection v1 Schema、五类 sink
+    最小投影和工作台隐私报告。
+  - 验收：覆盖序列号/WWN/主机名/IPv4/IPv6 的重复、大小写与分隔符变体；原文与自由文本不
+    进入 URL、日志、Analytics、AI 请求或导出；Secret 本地遮蔽；错误不回显；无网络、存储
+    和日志副作用。
 - [ ] **P3-004 [M] 实现规则化健康指标与未知状态**
 - [ ] **P3-005 [M] 实现 AI 通俗解释**
 - [ ] **P3-006 [M] 生成中文摘要与英文 RMA Markdown**
@@ -125,7 +130,7 @@
 
 ## 推荐下一项任务
 
-接下来做 **P3-003**：在浏览器内对用户粘贴的真实 SMART 文本实现序列号、WWN、主机名和
-IP 完整脱敏，并为后续导出与 AI 边界提供只含允许字段的结构化投影。必须覆盖大小上限、
-不同 smartctl 格式、重复标识、大小写与分隔符变体，以及 URL、日志、Analytics、导出和 AI
-请求不含原文的失败测试。每次仍只处理一个任务；健康分类由 P3-004 单独实现。
+接下来做 **P3-004**：基于 Parse Result v1 和 Boundary Projection v1 实现确定性的健康、
+注意、危险和未知分类。规则必须处理总体 PASSED 与关键计数非零的冲突，未知厂商属性不得
+强行判故障，SMART 不可用或关键字段缺失必须显式为未知；每条结论需指向输入信号和规则，
+不得调用 AI 或声称厂商必须保修。每次仍只处理一个任务。
diff --git a/apps/web/scripts/verify-static-output.mjs b/apps/web/scripts/verify-static-output.mjs
index 68c0997..13c5ee0 100644
--- a/apps/web/scripts/verify-static-output.mjs
+++ b/apps/web/scripts/verify-static-output.mjs
@@ -295,7 +295,20 @@ const checks = [
       "本阶段不调用",
       "不写入 URL",
       "Local Storage",
-      "不包含序列号、WWN、型号原文和原始文本",
+      "序列号、WWN、主机名和 IP",
+      "无自由文本的允许字段投影",
+    ].every((label) => smartRmaHtml.includes(label)),
+  ],
+  [
+    "SMART / RMA local redaction preview",
+    [
+      "本地解析并脱敏",
+      "本地脱敏预览",
+      "主机名 / 域名",
+      "查看脱敏后的本地文本",
+      "[REDACTED:SERIAL_NUMBER]",
+      "[REDACTED:WWN]",
+      "Boundary Projection v1",
     ].every((label) => smartRmaHtml.includes(label)),
   ],
   [
@@ -323,7 +336,8 @@ const checks = [
       styles.includes(".smart-rma-form textarea") &&
       styles.includes(".smart-rma-summary-grid") &&
       styles.includes(".smart-rma-table-scroll") &&
-      styles.includes(".smart-rma-nvme-grid"),
+      styles.includes(".smart-rma-nvme-grid") &&
+      styles.includes(".smart-rma-redaction-counts"),
   ],
 ];
 
diff --git a/apps/web/src/components/SmartRmaWorkbench.tsx b/apps/web/src/components/SmartRmaWorkbench.tsx
index 90c8b28..4d55211 100644
--- a/apps/web/src/components/SmartRmaWorkbench.tsx
+++ b/apps/web/src/components/SmartRmaWorkbench.tsx
@@ -1,5 +1,10 @@
 import { useMemo, useState } from "preact/hooks";
 
+import {
+  type SmartRmaRedactionPreview,
+  SmartRmaRedactionError,
+  redactSmartctlText,
+} from "../lib/smart-rma-redaction";
 import {
   type SmartRmaDeviceKind,
   type SmartRmaMissingField,
@@ -84,7 +89,7 @@ const initialStatus: WorkbenchStatus = {
   tone: "info",
   title: "合成样例已就绪",
   message:
-    "选择一个完全合成的 smartctl 样例，或粘贴文本后在当前浏览器标签页本地解析。",
+    "选择一个完全合成的 smartctl 样例，或粘贴文本后在当前浏览器标签页解析并脱敏。",
 };
 
 const formatMetric = (value: number | null, suffix = ""): string =>
@@ -101,8 +106,13 @@ export default function SmartRmaWorkbench({
 
   const [selectedSampleId, setSelectedSampleId] = useState(initialSample.id);
   const [rawText, setRawText] = useState(initialSample.raw);
-  const [result, setResult] = useState<SmartRmaParseResult | null>(() =>
-    parseSmartctlText(initialSample.raw),
+  const [redactionPreview, setRedactionPreview] =
+    useState<SmartRmaRedactionPreview | null>(() =>
+      redactSmartctlText(initialSample.raw),
+    );
+  const [result, setResult] = useState<SmartRmaParseResult | null>(
+    () =>
+      redactionPreview?.parse_result ?? parseSmartctlText(initialSample.raw),
   );
   const [status, setStatus] = useState<WorkbenchStatus>(initialStatus);
   const selectedSample = useMemo(
@@ -113,43 +123,60 @@ export default function SmartRmaWorkbench({
   const loadSelectedSample = (): void => {
     setRawText(selectedSample.raw);
     setResult(null);
+    setRedactionPreview(null);
     setStatus({
       tone: "info",
       title: "合成样例已载入",
-      message: `${selectedSample.label} 已放入输入框；点击“本地解析”查看结构化证据。`,
+      message: `${selectedSample.label} 已放入输入框；点击“本地解析并脱敏”查看结果。`,
     });
   };
 
   const parseLocally = (): void => {
     try {
-      const parsed = parseSmartctlText(rawText);
-      setResult(parsed);
+      const preview = redactSmartctlText(rawText);
+      setRedactionPreview(preview);
+      setResult(preview.parse_result);
       setStatus({
         tone: "ready",
-        title: "本地解析完成",
+        title: "本地解析与脱敏完成",
         message:
-          "只展示结构化字段和解析信号；原始文本、型号原文、序列号与 WWN 都不进入结果。",
+          "序列号、WWN、主机名、IP 与其他常见敏感值已遮蔽；跨边界只使用无自由文本的结构化投影。",
       });
     } catch (error) {
       setResult(null);
+      setRedactionPreview(null);
       setStatus({
         tone: "error",
-        title: "无法解析",
+        title: "无法解析或脱敏",
         message:
+          error instanceof SmartRmaRedactionError ||
           error instanceof SmartRmaParserError
             ? error.message
-            : "输入没有通过本地解析合同，请检查是否为 smartctl 文本。",
+            : "输入没有通过本地解析与脱敏合同，请检查是否为 smartctl 文本。",
       });
     }
   };
 
   const resetWorkbench = (): void => {
+    const preview = redactSmartctlText(initialSample.raw);
     setSelectedSampleId(initialSample.id);
     setRawText(initialSample.raw);
-    setResult(parseSmartctlText(initialSample.raw));
+    setRedactionPreview(preview);
+    setResult(preview.parse_result);
     setStatus(initialStatus);
   };
 
+  const updateRawText = (value: string): void => {
+    setRawText(value);
+    setResult(null);
+    setRedactionPreview(null);
+    setStatus({
+      tone: "info",
+      title: "输入已改变",
+      message: "点击“本地解析并脱敏”生成与当前文本对应的新结果。",
+    });
+  };
+
   return (
     <div class="smart-rma-shell">
       <section
@@ -205,8 +232,7 @@ export default function SmartRmaWorkbench({
           <label for="smartctl-text">
             <span>smartctl 文本</span>
             <small id="smartctl-text-help">
-              当前版本不导出原文；P3-003
-              完成前，请不要把真实文本复制到其他位置。
+              当前版本不导出原文；解析时会同时生成仅供本页查看的脱敏预览。
             </small>
           </label>
           <textarea
@@ -215,11 +241,11 @@ export default function SmartRmaWorkbench({
             aria-describedby="smartctl-text-help"
             value={rawText}
             spellcheck={false}
-            onInput={(event) => setRawText(event.currentTarget.value)}
+            onInput={(event) => updateRawText(event.currentTarget.value)}
           />
           <div class="smart-rma-actions">
             <button class="button button--primary" type="submit">
-              本地解析
+              本地解析并脱敏
             </button>
             <button class="button button--secondary" type="reset">
               恢复默认样例
@@ -231,14 +257,75 @@ export default function SmartRmaWorkbench({
           <strong>当前隐私边界</strong>
           <p>
             原始文本只存在于这个页面的内存，不写入 URL、Local
-            Storage、Analytics、日志或 AI
-            请求。解析结果也不包含序列号、WWN、型号原文和原始文本。
+            Storage、Analytics、日志、导出或 AI 请求。序列号、WWN、主机名和 IP
+            会在本地预览中遮蔽；未来跨边界能力只能读取无自由文本的允许字段投影。
           </p>
         </aside>
 
         <StatusNotice tone={status.tone} title={status.title}>
           {status.message}
         </StatusNotice>
+
+        {redactionPreview && (
+          <section
+            class="smart-rma-redaction"
+            aria-labelledby="smart-rma-redaction-heading"
+          >
+            <div class="smart-rma-detail-heading">
+              <div>
+                <p class="section-kicker">LOCAL REDACTION</p>
+                <h3 id="smart-rma-redaction-heading">本地脱敏预览</h3>
+              </div>
+              <p>
+                共遮蔽 {redactionPreview.projection.privacy.redactions_total}{" "}
+                处；报告只保留类型和数量。
+              </p>
+            </div>
+
+            <dl class="smart-rma-redaction-counts">
+              <div>
+                <dt>序列号</dt>
+                <dd>
+                  {redactionPreview.projection.privacy.counts.serial_number}
+                </dd>
+              </div>
+              <div>
+                <dt>WWN</dt>
+                <dd>{redactionPreview.projection.privacy.counts.wwn}</dd>
+              </div>
+              <div>
+                <dt>主机名 / 域名</dt>
+                <dd>{redactionPreview.projection.privacy.counts.domain}</dd>
+              </div>
+              <div>
+                <dt>IP</dt>
+                <dd>{redactionPreview.projection.privacy.counts.ip}</dd>
+              </div>
+              <div>
+                <dt>邮箱</dt>
+                <dd>{redactionPreview.projection.privacy.counts.email}</dd>
+              </div>
+              <div>
+                <dt>Secret</dt>
+                <dd>
+                  {redactionPreview.projection.privacy.counts.authorization +
+                    redactionPreview.projection.privacy.counts.cookie +
+                    redactionPreview.projection.privacy.counts.token}
+                </dd>
+              </div>
+            </dl>
+
+            <details>
+              <summary>查看脱敏后的本地文本</summary>
+              <pre>{redactionPreview.redacted_text}</pre>
+            </details>
+            <p class="smart-rma-boundary-note">
+              AI
+              与导出不会接收这段文本，只能使用协议、计数、枚举和受支持指标组成的
+              Boundary Projection v1。
+            </p>
+          </section>
+        )}
       </section>
 
       <section
@@ -406,7 +493,8 @@ export default function SmartRmaWorkbench({
           </>
         ) : (
           <p class="smart-rma-empty">
-            尚无解析结果。载入合成样例或粘贴 smartctl 文本后，点击“本地解析”。
+            尚无解析结果。载入合成样例或粘贴 smartctl
+            文本后，点击“本地解析并脱敏”。
           </p>
         )}
 
diff --git a/apps/web/src/lib/smart-rma-redaction.test.ts b/apps/web/src/lib/smart-rma-redaction.test.ts
new file mode 100644
index 0000000..e4ce388
--- /dev/null
+++ b/apps/web/src/lib/smart-rma-redaction.test.ts
@@ -0,0 +1,244 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { loadSmartRmaFixtureCorpus } from "./smart-rma-fixtures";
+import {
+  SmartRmaRedactionError,
+  createSmartRmaBoundaryPayload,
+  redactSmartctlText,
+  validateSmartRmaBoundaryProjection,
+} from "./smart-rma-redaction";
+
+const edgeCaseSmartctl = [
+  "smartctl 7.4 synthetic edge case",
+  "Device Model: MARGROP LABS SYNTHETIC EDGE",
+  "Device Serial No. = SYNTHETIC-EDGE-SERIAL-0001",
+  "serialnumber: SYNTHETIC-EDGE-SERIAL-0002",
+  "S/N: SYNTHETIC-EDGE-SERIAL-0003",
+  "Serial Number: SYNTHETIC EDGE SERIAL 0004",
+  "LU WWN Device Id: 0 000000 000000001",
+  "WWN_Device_Id=0x0000000000000001",
+  "Host Name: SYNTHETIC_HOST_01",
+  "Computer_Name=storage-node-02.example.com",
+  "IPv4 Address: 192.0.2.44",
+  "IPv6 Address: [2001:db8::44]",
+  "ATA Version is: ACS-4 synthetic",
+  "SMART support is: Available",
+  "SMART overall-health self-assessment test result: PASSED",
+  "",
+].join("\n");
+
+const edgeCaseRawValues = [
+  "SYNTHETIC-EDGE-SERIAL-0001",
+  "SYNTHETIC-EDGE-SERIAL-0002",
+  "SYNTHETIC-EDGE-SERIAL-0003",
+  "SYNTHETIC EDGE SERIAL 0004",
+  "0 000000 000000001",
+  "0x0000000000000001",
+  "SYNTHETIC_HOST_01",
+  "storage-node-02.example.com",
+  "192.0.2.44",
+  "2001:db8::44",
+];
+
+describe("SMART / RMA local redaction preview v1", () => {
+  it("redacts identifiers from every indexed synthetic fixture and preserves parse evidence", async () => {
+    const corpus = await loadSmartRmaFixtureCorpus();
+
+    for (const fixture of corpus.fixtures) {
+      const preview = redactSmartctlText(fixture.raw);
+      const serial = /^Serial Number:\s*(\S+)/imu.exec(fixture.raw)?.[1];
+      const wwn = /^LU WWN Device Id:\s*(.+)$/imu.exec(fixture.raw)?.[1];
+
+      for (const value of [serial, wwn]) {
+        if (value) {
+          expect(preview.redacted_text, fixture.id).not.toContain(value.trim());
+        }
+      }
+      expect(preview.projection.protocol, fixture.id).toBe(fixture.protocol);
+      expect(preview.projection.signals, fixture.id).toEqual(
+        fixture.expected_signals,
+      );
+      expect(preview.projection.missing_fields, fixture.id).toEqual(
+        fixture.missing_fields,
+      );
+    }
+  });
+
+  it("covers repeated labels, separators, case, host names and IPv4/IPv6", () => {
+    const preview = redactSmartctlText(edgeCaseSmartctl);
+
+    for (const value of edgeCaseRawValues) {
+      expect(preview.redacted_text).not.toContain(value);
+    }
+    expect(preview.redacted_text).toContain("[REDACTED:SERIAL_NUMBER]");
+    expect(preview.redacted_text).toContain("[REDACTED:WWN]");
+    expect(preview.redacted_text).toContain("[REDACTED:DOMAIN]");
+    expect(preview.redacted_text).toContain("[REDACTED:IP]");
+    expect(preview.projection.privacy).toEqual({
+      redactions_total: 10,
+      counts: {
+        authorization: 0,
+        cookie: 0,
+        token: 0,
+        email: 0,
+        ip: 2,
+        domain: 2,
+        serial_number: 4,
+        wwn: 2,
+      },
+    });
+  });
+
+  it("normalizes privacy treatment without changing line endings or retaining secrets", () => {
+    const secret = "synthetic-secret-value";
+    const source = edgeCaseSmartctl
+      .replaceAll("\n", "\r\n")
+      .replace(
+        "ATA Version is:",
+        `Authorization: Bearer ${secret}\r\nToken=${secret}\r\nATA Version is:`,
+      );
+    const preview = redactSmartctlText(source);
+
+    expect(preview.redacted_text).toContain("\r\n");
+    expect(preview.redacted_text).toContain("[REDACTED:AUTHORIZATION]");
+    expect(preview.redacted_text).toContain("[REDACTED:TOKEN]");
+    expect(preview.redacted_text).not.toContain(secret);
+    expect(preview.projection.privacy.counts.authorization).toBe(1);
+    expect(preview.projection.privacy.counts.token).toBe(1);
+  });
+
+  it("creates an allowlisted projection without raw text or free-form attribute names", async () => {
+    const corpus = await loadSmartRmaFixtureCorpus();
+    const fixture = corpus.fixtures.find(
+      ({ id }) => id === "ata-vendor-extension-7-3",
+    );
+    if (!fixture) {
+      throw new Error("Synthetic vendor-extension fixture is required.");
+    }
+
+    const preview = redactSmartctlText(fixture.raw);
+    const serialized = JSON.stringify(preview.projection);
+
+    expect(validateSmartRmaBoundaryProjection(preview.projection)).toEqual(
+      preview.projection,
+    );
+    expect(
+      preview.projection.ata.attributes.every(({ id }) => id !== 170),
+    ).toBe(true);
+    expect(preview.projection).not.toHaveProperty("serial_number");
+    expect(preview.projection).not.toHaveProperty("wwn");
+    for (const forbidden of [
+      "redacted_text",
+      "raw_text",
+      "Device Model",
+      "Vendor_Health_Reserve",
+    ]) {
+      expect(serialized).not.toContain(forbidden);
+    }
+    expect(() =>
+      validateSmartRmaBoundaryProjection({
+        ...preview.projection,
+        raw_text: fixture.raw,
+      }),
+    ).toThrow(/smart-rma-boundary-projection-v1/);
+  });
+
+  it.each(["url", "log", "analytics", "ai-request", "export"] as const)(
+    "keeps raw identifiers out of the %s boundary",
+    (boundary) => {
+      const preview = redactSmartctlText(edgeCaseSmartctl);
+      const payload = createSmartRmaBoundaryPayload(
+        preview.projection,
+        boundary,
+      );
+      const serialized = JSON.stringify(payload);
+
+      for (const value of edgeCaseRawValues) {
+        expect(serialized).not.toContain(value);
+      }
+      expect(serialized).not.toContain("redacted_text");
+      expect(serialized).not.toContain("Device Model");
+    },
+  );
+
+  it("limits URL, log and Analytics payloads to stable metadata", () => {
+    const projection = redactSmartctlText(edgeCaseSmartctl).projection;
+
+    expect(createSmartRmaBoundaryPayload(projection, "url")).toEqual({
+      lab_id: "smart-rma",
+      view: "workbench",
+    });
+    expect(createSmartRmaBoundaryPayload(projection, "log")).toEqual({
+      lab_id: "smart-rma",
+      action: "redact",
+      outcome: "success",
+      redactions_total: 10,
+    });
+    expect(createSmartRmaBoundaryPayload(projection, "analytics")).toEqual({
+      lab_id: "smart-rma",
+      event_name: "redact_success",
+      protocol: "ata",
+    });
+  });
+
+  it("fails closed on invalid, oversized and unsupported input without echoing it", () => {
+    const privateValue = "private-input-value";
+    const cases: Array<{
+      input: unknown;
+      code: SmartRmaRedactionError["code"];
+    }> = [
+      { input: null, code: "invalid-input" },
+      { input: "", code: "invalid-input" },
+      { input: `plain ${privateValue}`, code: "unsupported-format" },
+      {
+        input: `smartctl 7.4 synthetic\n${"x".repeat(65 * 1024)}`,
+        code: "input-too-large",
+      },
+      {
+        input: `smartctl 7.4 synthetic\n${"SN:a\n".repeat(10_000)}`,
+        code: "output-too-large",
+      },
+    ];
+
+    for (const testCase of cases) {
+      let receivedError: unknown;
+      try {
+        redactSmartctlText(testCase.input);
+      } catch (error) {
+        receivedError = error;
+      }
+
+      expect(receivedError).toBeInstanceOf(SmartRmaRedactionError);
+      expect((receivedError as SmartRmaRedactionError).code).toBe(
+        testCase.code,
+      );
+      expect(String(receivedError)).not.toContain(privateValue);
+    }
+  });
+
+  it("has no network, storage or console side effects", () => {
+    const fetchSpy = vi.fn();
+    const storageWriteSpy = vi.fn();
+    const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const consoleWarnSpy = vi
+      .spyOn(console, "warn")
+      .mockImplementation(() => {});
+    const consoleErrorSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    vi.stubGlobal("fetch", fetchSpy);
+    vi.stubGlobal("localStorage", {
+      setItem: storageWriteSpy,
+    });
+
+    redactSmartctlText(edgeCaseSmartctl);
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    expect(storageWriteSpy).not.toHaveBeenCalled();
+    expect(consoleLogSpy).not.toHaveBeenCalled();
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+    expect(consoleErrorSpy).not.toHaveBeenCalled();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+});
diff --git a/apps/web/src/lib/smart-rma-redaction.ts b/apps/web/src/lib/smart-rma-redaction.ts
new file mode 100644
index 0000000..fabb9ce
--- /dev/null
+++ b/apps/web/src/lib/smart-rma-redaction.ts
@@ -0,0 +1,277 @@
+import {
+  type RedactionReport,
+  redactTextWithReport,
+} from "@margrop-labs/redaction";
+import Ajv2020, {
+  type ErrorObject,
+  type ValidateFunction,
+} from "ajv/dist/2020.js";
+import type { AnySchema } from "ajv";
+
+import boundaryProjectionSchema from "../../../../schemas/smart-rma-boundary-projection-v1.schema.json";
+import {
+  type SmartRmaAtaAttribute,
+  type SmartRmaDeviceKind,
+  type SmartRmaMissingField,
+  type SmartRmaParseResult,
+  type SmartRmaProtocol,
+  type SmartRmaReportedHealth,
+  type SmartRmaSignal,
+  type SmartRmaSupport,
+  SmartRmaParserError,
+  parseSmartctlText,
+} from "./smart-rma-parser";
+
+export const smartRmaRedactionLimits = Object.freeze({
+  maximumRedactedBytes: 128 * 1024,
+});
+
+export type SmartRmaPrivacyCounts = {
+  authorization: number;
+  cookie: number;
+  token: number;
+  email: number;
+  ip: number;
+  domain: number;
+  serial_number: number;
+  wwn: number;
+};
+
+export type SmartRmaBoundaryAtaAttribute = Pick<
+  SmartRmaAtaAttribute,
+  | "id"
+  | "normalized_value"
+  | "worst_value"
+  | "threshold"
+  | "when_failed"
+  | "raw_value"
+>;
+
+export type SmartRmaBoundaryProjection = {
+  schema_version: "1.0";
+  parser_version: "1.0";
+  redactor_version: "1.0";
+  protocol: SmartRmaProtocol;
+  device_kind: SmartRmaDeviceKind;
+  smart_support: SmartRmaSupport;
+  reported_overall_health: SmartRmaReportedHealth;
+  signals: SmartRmaSignal[];
+  missing_fields: SmartRmaMissingField[];
+  temperature_celsius: number | null;
+  power_on_hours: number | null;
+  ata: {
+    attributes: SmartRmaBoundaryAtaAttribute[];
+    error_count: number | null;
+    self_test_failure_count: number;
+  };
+  nvme: SmartRmaParseResult["nvme"];
+  privacy: {
+    redactions_total: number;
+    counts: SmartRmaPrivacyCounts;
+  };
+};
+
+export type SmartRmaRedactionPreview = {
+  redacted_text: string;
+  parse_result: SmartRmaParseResult;
+  projection: SmartRmaBoundaryProjection;
+};
+
+export type SmartRmaBoundary =
+  "url" | "log" | "analytics" | "ai-request" | "export";
+
+export type SmartRmaBoundaryPayload =
+  | {
+      lab_id: "smart-rma";
+      view: "workbench";
+    }
+  | {
+      lab_id: "smart-rma";
+      action: "redact";
+      outcome: "success";
+      redactions_total: number;
+    }
+  | {
+      lab_id: "smart-rma";
+      event_name: "redact_success";
+      protocol: SmartRmaProtocol;
+    }
+  | SmartRmaBoundaryProjection;
+
+export class SmartRmaRedactionError extends Error {
+  readonly code:
+    | "invalid-input"
+    | "input-too-large"
+    | "unsupported-format"
+    | "output-too-large"
+    | "invalid-projection";
+
+  constructor(code: SmartRmaRedactionError["code"], message: string) {
+    super(message);
+    this.name = "SmartRmaRedactionError";
+    this.code = code;
+  }
+}
+
+const formatValidationErrors = (
+  errors: ErrorObject[] | null | undefined,
+): string =>
+  (errors ?? [])
+    .map((error) => {
+      const location = error.instancePath || "/";
+      return `${location} ${error.message ?? "is invalid"}`;
+    })
+    .join("; ");
+
+const ajv = new Ajv2020({
+  allErrors: true,
+  strict: true,
+});
+const validateBoundaryProjectionSchema: ValidateFunction<SmartRmaBoundaryProjection> =
+  ajv.compile(boundaryProjectionSchema as AnySchema);
+
+export const validateSmartRmaBoundaryProjection = (
+  candidate: unknown,
+): SmartRmaBoundaryProjection => {
+  if (!validateBoundaryProjectionSchema(candidate)) {
+    throw new SmartRmaRedactionError(
+      "invalid-projection",
+      `SMART boundary projection did not match smart-rma-boundary-projection-v1: ${formatValidationErrors(validateBoundaryProjectionSchema.errors)}`,
+    );
+  }
+
+  return candidate as SmartRmaBoundaryProjection;
+};
+
+const privacyCounts = (report: RedactionReport): SmartRmaPrivacyCounts => ({
+  authorization: report.counts.authorization ?? 0,
+  cookie: report.counts.cookie ?? 0,
+  token: report.counts.token ?? 0,
+  email: report.counts.email ?? 0,
+  ip: report.counts.ip ?? 0,
+  domain: report.counts.domain ?? 0,
+  serial_number: report.counts["serial-number"] ?? 0,
+  wwn: report.counts.wwn ?? 0,
+});
+
+export const createSmartRmaBoundaryProjection = (
+  parsed: SmartRmaParseResult,
+  report: RedactionReport,
+): SmartRmaBoundaryProjection =>
+  validateSmartRmaBoundaryProjection({
+    schema_version: "1.0",
+    parser_version: parsed.parser_version,
+    redactor_version: "1.0",
+    protocol: parsed.protocol,
+    device_kind: parsed.device_kind,
+    smart_support: parsed.smart_support,
+    reported_overall_health: parsed.reported_overall_health,
+    signals: [...parsed.signals],
+    missing_fields: [...parsed.missing_fields],
+    temperature_celsius: parsed.temperature_celsius,
+    power_on_hours: parsed.power_on_hours,
+    ata: {
+      attributes: parsed.ata.attributes
+        .filter(({ recognized }) => recognized)
+        .map(
+          ({
+            id,
+            normalized_value,
+            worst_value,
+            threshold,
+            when_failed,
+            raw_value,
+          }) => ({
+            id,
+            normalized_value,
+            worst_value,
+            threshold,
+            when_failed,
+            raw_value,
+          }),
+        ),
+      error_count: parsed.ata.error_count,
+      self_test_failure_count: parsed.ata.self_test_failure_count,
+    },
+    nvme: {
+      critical_warning: parsed.nvme.critical_warning,
+      available_spare_percent: parsed.nvme.available_spare_percent,
+      available_spare_threshold_percent:
+        parsed.nvme.available_spare_threshold_percent,
+      percentage_used: parsed.nvme.percentage_used,
+      media_errors: parsed.nvme.media_errors,
+      error_log_entries: parsed.nvme.error_log_entries,
+    },
+    privacy: {
+      redactions_total: report.total,
+      counts: privacyCounts(report),
+    },
+  });
+
+const translateParserError = (error: SmartRmaParserError): never => {
+  const code =
+    error.code === "invalid-result" ? "invalid-projection" : error.code;
+  throw new SmartRmaRedactionError(code, error.message);
+};
+
+export const redactSmartctlText = (
+  candidate: unknown,
+): SmartRmaRedactionPreview => {
+  let parsed: SmartRmaParseResult;
+  try {
+    parsed = parseSmartctlText(candidate);
+  } catch (error) {
+    if (error instanceof SmartRmaParserError) {
+      return translateParserError(error);
+    }
+    throw error;
+  }
+
+  const redacted = redactTextWithReport(candidate as string);
+  if (
+    new TextEncoder().encode(redacted.text).byteLength >
+    smartRmaRedactionLimits.maximumRedactedBytes
+  ) {
+    throw new SmartRmaRedactionError(
+      "output-too-large",
+      "Redacted SMART preview exceeded its deterministic size limit.",
+    );
+  }
+
+  return {
+    redacted_text: redacted.text,
+    parse_result: parsed,
+    projection: createSmartRmaBoundaryProjection(parsed, redacted.report),
+  };
+};
+
+export const createSmartRmaBoundaryPayload = (
+  candidate: unknown,
+  boundary: SmartRmaBoundary,
+): SmartRmaBoundaryPayload => {
+  const projection = validateSmartRmaBoundaryProjection(candidate);
+
+  switch (boundary) {
+    case "url":
+      return {
+        lab_id: "smart-rma",
+        view: "workbench",
+      };
+    case "log":
+      return {
+        lab_id: "smart-rma",
+        action: "redact",
+        outcome: "success",
+        redactions_total: projection.privacy.redactions_total,
+      };
+    case "analytics":
+      return {
+        lab_id: "smart-rma",
+        event_name: "redact_success",
+        protocol: projection.protocol,
+      };
+    case "ai-request":
+    case "export":
+      return projection;
+  }
+};
diff --git a/apps/web/src/pages/smart-rma/index.astro b/apps/web/src/pages/smart-rma/index.astro
index db1b29b..af27ec0 100644
--- a/apps/web/src/pages/smart-rma/index.astro
+++ b/apps/web/src/pages/smart-rma/index.astro
@@ -32,7 +32,7 @@ const samples: SmartRmaSample[] = corpus.fixtures.map(({ id, raw }) => ({
 
 <BaseLayout
   title="SMART / RMA 报告机｜Margrop Labs"
-  description="在浏览器本地解析 smartctl 文本，识别 ATA、NVMe、关键属性、错误计数与缺失字段，不上传或保存原始输入。"
+  description="在浏览器本地解析并脱敏 smartctl 文本，识别 ATA、NVMe、关键属性、错误计数与缺失字段，不上传或保存原始输入。"
 >
   <section class="lab-page">
     <header class="lab-page-hero">
@@ -41,14 +41,15 @@ const samples: SmartRmaSample[] = corpus.fixtures.map(({ id, raw }) => ({
         <h1>先看懂 SMART，<br /><em>再谈健康结论。</em></h1>
         <p>
           粘贴 smartctl 文本或加载完全合成样例。浏览器只做确定性结构化解析，
-          把工具报告、异常信号和未知项分开，不把 PASSED 包装成保修结论。
+          同时遮蔽序列号、WWN、主机名和 IP，把工具报告、异常信号和未知项分开，
+          不把 PASSED 包装成保修结论。
         </p>
       </div>
       <dl class="lab-page-contract">
         <div><dt>RAW INPUT</dt><dd>仅当前标签页</dd></div>
         <div><dt>NETWORK</dt><dd>不上传文本</dd></div>
         <div><dt>AI</dt><dd>本阶段不调用</dd></div>
-        <div><dt>OUTPUT</dt><dd>仅解析证据</dd></div>
+        <div><dt>OUTPUT</dt><dd>脱敏结构证据</dd></div>
       </dl>
     </header>
 
diff --git a/apps/web/src/styles/global.css b/apps/web/src/styles/global.css
index 31b0a46..43a0900 100644
--- a/apps/web/src/styles/global.css
+++ b/apps/web/src/styles/global.css
@@ -2050,6 +2050,89 @@ a {
   margin-top: 1.25rem;
 }
 
+.smart-rma-redaction {
+  margin-top: 1.25rem;
+  padding: 1rem;
+  border: 1px solid var(--line);
+  border-radius: 0.8rem;
+  background: rgba(8, 17, 31, 0.4);
+}
+
+.smart-rma-redaction .section-kicker {
+  margin-bottom: 0.5rem;
+}
+
+.smart-rma-redaction-counts {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0;
+  margin: 1rem 0;
+  border: 1px solid var(--line);
+  border-radius: 0.7rem;
+  overflow: hidden;
+}
+
+.smart-rma-redaction-counts > div {
+  padding: 0.8rem;
+  border-right: 1px solid var(--line);
+  border-bottom: 1px solid var(--line);
+}
+
+.smart-rma-redaction-counts > div:nth-child(3n) {
+  border-right: 0;
+}
+
+.smart-rma-redaction-counts > div:nth-last-child(-n + 3) {
+  border-bottom: 0;
+}
+
+.smart-rma-redaction-counts dt {
+  color: var(--muted);
+  font-size: 0.72rem;
+}
+
+.smart-rma-redaction-counts dd {
+  margin: 0.35rem 0 0;
+  color: var(--cyan);
+  font-family: ui-monospace, "SFMono-Regular", Consolas, monospace;
+  font-size: 1.15rem;
+  font-weight: 800;
+}
+
+.smart-rma-redaction details {
+  border: 1px solid var(--line);
+  border-radius: 0.7rem;
+}
+
+.smart-rma-redaction summary {
+  display: flex;
+  min-height: 44px;
+  align-items: center;
+  padding: 0.75rem;
+  cursor: pointer;
+  font-weight: 700;
+}
+
+.smart-rma-redaction pre {
+  max-height: 26rem;
+  margin: 0;
+  overflow: auto;
+  padding: 0.9rem;
+  border-top: 1px solid var(--line);
+  color: var(--muted);
+  font-size: 0.72rem;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.smart-rma-boundary-note {
+  margin: 0.9rem 0 0;
+  color: var(--muted);
+  font-size: 0.8rem;
+  line-height: 1.6;
+}
+
 .smart-rma-facts,
 .smart-rma-nvme-grid {
   display: grid;
@@ -2417,14 +2500,18 @@ a {
 
   .smart-rma-sample-controls,
   .smart-rma-facts,
-  .smart-rma-nvme-grid {
+  .smart-rma-nvme-grid,
+  .smart-rma-redaction-counts {
     grid-template-columns: 1fr;
   }
 
   .smart-rma-facts > div,
   .smart-rma-nvme-grid > div,
   .smart-rma-facts > div:nth-child(3n),
-  .smart-rma-nvme-grid > div:nth-child(3n) {
+  .smart-rma-nvme-grid > div:nth-child(3n),
+  .smart-rma-redaction-counts > div,
+  .smart-rma-redaction-counts > div:nth-child(3n),
+  .smart-rma-redaction-counts > div:nth-last-child(-n + 3) {
     border-right: 0;
     border-bottom: 1px solid var(--line);
   }
@@ -2434,6 +2521,10 @@ a {
     border-bottom: 0;
   }
 
+  .smart-rma-redaction-counts > div:last-child {
+    border-bottom: 0;
+  }
+
   .smart-rma-actions .button,
   .smart-rma-next-links .button,
   .smart-rma-sample-controls .button {
@@ -2481,7 +2572,9 @@ a {
   .smart-rma-form textarea,
   .smart-rma-summary-grid > section,
   .smart-rma-detail,
-  .smart-rma-table-scroll {
+  .smart-rma-table-scroll,
+  .smart-rma-redaction,
+  .smart-rma-redaction details {
     border-color: ButtonText;
   }
 }
diff --git a/docs/smart-rma-parser-v1.md b/docs/smart-rma-parser-v1.md
index dbff509..3bc4ede 100644
--- a/docs/smart-rma-parser-v1.md
+++ b/docs/smart-rma-parser-v1.md
@@ -12,8 +12,9 @@ P3-002 在 `/smart-rma/` 提供一个确定性的浏览器端 `smartctl` 解析
 - 原始文本仅保留在当前组件内存，不进入 URL、Local Storage、日志、Analytics 或 AI；
 - 公开页面默认加载 P3-001 的完全合成样例，用户无需登录或提供真实设备数据。
 
-P3-003 才会实现对真实输入的序列号、WWN、主机名和 IP 完整脱敏。在此之前，解析结果主动
-不保留原始文本、型号原文、序列号和 WWN，也不提供原文导出。
+P3-003 已在解析前后增加本地脱敏预览和无自由文本的边界投影。解析结果仍主动不保留原始
+文本、型号原文、序列号和 WWN；完整规则见
+[SMART / RMA 本地脱敏与边界投影 v1](./smart-rma-redaction-v1.md)。
 
 ## 确定性输出
 
diff --git a/docs/smart-rma-redaction-v1.md b/docs/smart-rma-redaction-v1.md
new file mode 100644
index 0000000..f8a2c4b
--- /dev/null
+++ b/docs/smart-rma-redaction-v1.md
@@ -0,0 +1,80 @@
+# SMART / RMA 本地脱敏与边界投影 v1
+
+P3-003 为 `/smart-rma/` 增加两层确定性隐私边界：
+
+1. 浏览器内生成可人工检查的脱敏文本预览；
+2. 为未来 AI 与导出生成无自由文本的
+   [`smart-rma-boundary-projection-v1`](../schemas/smart-rma-boundary-projection-v1.schema.json)。
+
+原始 `smartctl` 文本只存在于当前组件内存，不进入 URL、Local Storage、日志、Analytics、
+AI 请求或导出。修改输入会立即清除旧的解析结果和脱敏预览；重置只恢复公开合成样例。
+
+## 本地脱敏预览
+
+输入先通过 P3-002 的 smartctl 格式和 64 KiB 上限，再由
+[`@margrop-labs/redaction`](../packages/redaction/README.md) 同步处理。当前明确覆盖：
+
+- `Serial Number`、`Device Serial No.`、`SerialNumber`、`S/N`、`SN` 等有标签序列号；
+- `WWN`、`WWN Device Id`、`LU WWN Device Id` 与 `World Wide Name`；
+- `Host`、`Host Name`、`Hostname`、`Computer Name`、`Node Name`、`System Name` 和域名；
+- 合法 IPv4、压缩或完整 IPv6；
+- 邮箱、Authorization、Cookie 与常见有标签 Token，作为纵深防御。
+
+大小写、空格、横线、下划线以及 `:`、`=` 分隔符均有合成测试。重复标识逐次替换为固定占位
+符，不保留原值长度、前后缀、哈希或位置。脱敏报告只包含类型和数量；主机名与域名统一计入
+`domain`。
+
+本地预览最多 128 KiB，用于容纳固定占位符可能带来的扩张。预览不提供复制、下载或分享
+动作；P3-006 的正式导出也只能读取 Boundary Projection，不能读取这段预览文本。
+
+## Boundary Projection v1
+
+投影采用显式字段映射，不展开或透传解析结果。它只包含：
+
+- 协议、设备类别、SMART 支持和 smartctl 报告的总体状态；
+- 稳定信号、缺失字段、温度和通电小时；
+- 已知 ATA 属性 ID 5、9、187、194、197、198 的数值，不包含属性名称；
+- ATA 错误/自检计数和 NVMe 健康计数；
+- 各敏感类型的替换数量。
+
+它不包含原始或脱敏文本、型号、固件原文、序列号、WWN、主机名、IP、邮箱、厂商扩展属性
+名称、URL、用户标识或时间戳。未知 ATA 属性只保留 `vendor-extension` 信号，不把名称或数值
+送出浏览器。
+
+## Sink 最小化
+
+同一个输入不能直接复用于所有边界：
+
+| 边界      | v1 允许内容                                        |
+| --------- | -------------------------------------------------- |
+| URL       | 固定 Lab ID 与 `workbench` 视图                    |
+| 日志      | 固定动作/结果与替换总数，不含正文                  |
+| Analytics | 固定事件名与协议枚举；P4-003 前仍无接收器          |
+| AI 请求   | 完整 Boundary Projection；P3-005 前不调用 Provider |
+| 导出      | 完整 Boundary Projection；P3-006 前不生成用户文件  |
+
+这些投影函数只构造对象，不执行网络、存储、日志或剪贴板操作。
+
+## 失败模型
+
+| 错误码               | 含义                              |
+| -------------------- | --------------------------------- |
+| `invalid-input`      | 非字符串、空输入或非法文本字符    |
+| `input-too-large`    | 原始 UTF-8 输入超过 64 KiB        |
+| `unsupported-format` | 缺少受支持的 smartctl 版本横幅    |
+| `output-too-large`   | 脱敏预览超过 128 KiB              |
+| `invalid-projection` | 解析或投影结果未通过版本化 Schema |
+
+错误消息不回显用户输入。
+
+## 已知边界
+
+模式检测无法可靠区分所有无标签随机字符串和普通文本，因此“替换数量为 0”不是安全证明。安全
+主线始终是：原文不离开浏览器、跨边界只使用无自由文本的允许字段投影、Secret 与 Provider
+密钥仍由服务端隔离。P3-004 才负责健康分类，P3-005/P3-006 才分别接入 AI 解释和正式导出。
+
+## 验证
+
+测试覆盖全部 7 份 P3-001 合成 fixture，以及重复标签、标签与分隔符变体、含下划线主机名、
+IPv4/IPv6、CRLF、Secret、64 KiB 上限、Schema 额外字段拒绝、未知厂商属性丢弃和五类 sink
+不含原值。测试同时断言无网络、存储或控制台副作用。
diff --git a/labs/smart-rma/README.md b/labs/smart-rma/README.md
index f086842..8234bcb 100644
--- a/labs/smart-rma/README.md
+++ b/labs/smart-rma/README.md
@@ -45,4 +45,18 @@ P3-002 已上线 `/smart-rma/` Alpha 工作台：可载入上述 7 份合成样
   [SMART / RMA 浏览器解析器 v1](../../docs/smart-rma-parser-v1.md)
 
 解析结果不包含原始文本、型号原文、序列号或 WWN。P3-002 不做健康分类，也不声称设备满足
-厂商保修条件；完整输入脱敏由 P3-003 实现。
+厂商保修条件。
+
+## 本地脱敏与边界投影
+
+P3-003 已在工作台加入只在当前页面内存生成的脱敏预览，覆盖序列号、WWN、主机名、IPv4、
+IPv6、邮箱和常见 Secret。未来 AI 与导出不能读取预览文本，只能消费无自由文本的版本化
+投影。
+
+- 投影合同：
+  [`smart-rma-boundary-projection-v1`](../../schemas/smart-rma-boundary-projection-v1.schema.json)
+- 模式、sink 最小化与失败边界：
+  [SMART / RMA 本地脱敏与边界投影 v1](../../docs/smart-rma-redaction-v1.md)
+
+模式命中数量不是“输入一定安全”的证明；原文不离开浏览器和显式允许字段映射才是主边界。
+健康分类仍由 P3-004 单独实现。
diff --git a/labs/smart-rma/lab.json b/labs/smart-rma/lab.json
index 1bf59d0..a063bc0 100644
--- a/labs/smart-rma/lab.json
+++ b/labs/smart-rma/lab.json
@@ -2,7 +2,7 @@
   "schema_version": "1.0",
   "id": "smart-rma",
   "title": "SMART / RMA 报告机",
-  "summary": "在浏览器本地解析 SMART 输出，分离工具状态、关键指标与未知项。",
+  "summary": "在浏览器本地解析并遮蔽 SMART 标识，分离工具状态、关键指标与未知项。",
   "status": "alpha",
   "route": "/smart-rma/",
   "ai_mode": "optional",
diff --git a/packages/redaction/README.md b/packages/redaction/README.md
index 578b66e..fff1ce7 100644
--- a/packages/redaction/README.md
+++ b/packages/redaction/README.md
@@ -10,6 +10,10 @@ P0-007 首批覆盖：
 - Authorization、Token 与 Cookie；
 - 有标签的序列号与 WWN。
 
+P3-003 扩展了常见 smartctl 与主机标签变体，包括 `Device Serial No.`、`SerialNumber`、
+`LU WWN Device Id`、`Host Name`、`Computer Name` 等；有标签主机名允许真实环境中常见的
+下划线，但仍只返回固定占位符。
+
 ## 处理顺序
 
 结构化输入必须调用 `sanitizeAllowedFields`，顺序固定为：
diff --git a/packages/redaction/src/index.test.ts b/packages/redaction/src/index.test.ts
index 7942705..bf053ff 100644
--- a/packages/redaction/src/index.test.ts
+++ b/packages/redaction/src/index.test.ts
@@ -139,6 +139,43 @@ describe("redactText", () => {
     });
   });
 
+  it("covers smartctl identifier labels and common host-name variants", () => {
+    const values = [
+      "SYNTHETIC SERIAL EDGE 0001",
+      "0 000000 000000001",
+      "SYNTHETIC_HOST_01",
+      "storage-node-02.example.com",
+    ];
+    const result = redactTextWithReport(
+      [
+        `Device Serial No. = ${values[0]}`,
+        `LU WWN Device Id: ${values[1]}`,
+        `Host Name: ${values[2]}`,
+        `Computer_Name=${values[3]}`,
+      ].join("\n"),
+    );
+
+    expect(result.text).toBe(
+      [
+        "Device Serial No. = [REDACTED:SERIAL_NUMBER]",
+        "LU WWN Device Id: [REDACTED:WWN]",
+        "Host Name: [REDACTED:DOMAIN]",
+        "Computer_Name=[REDACTED:DOMAIN]",
+      ].join("\n"),
+    );
+    for (const value of values) {
+      expect(result.text).not.toContain(value);
+    }
+    expect(result.report).toEqual({
+      total: 4,
+      counts: {
+        domain: 2,
+        "serial-number": 1,
+        wwn: 1,
+      },
+    });
+  });
+
   it("does not treat common source file names or invalid IPs as secrets", () => {
     const source =
       "Inspect src/index.ts, schema.json, version 999.2.3.4 and separator :::.";
diff --git a/packages/redaction/src/index.ts b/packages/redaction/src/index.ts
index 6fbcc98..e9d786a 100644
--- a/packages/redaction/src/index.ts
+++ b/packages/redaction/src/index.ts
@@ -291,7 +291,7 @@ const redactLabelledHardwareIds = (
   counts: MutableCounts,
 ): string => {
   let redacted = input.replace(
-    /(^|[^A-Za-z0-9_-])((?:wwn|world[ \t]+wide[ \t]+name))(\s*[:=]\s*)((?:0x)?[A-Fa-f0-9][A-Fa-f0-9 :.-]{6,}[A-Fa-f0-9])/gi,
+    /(^|[^A-Za-z0-9_-])((?:(?:lu[ \t_-]+)?wwn(?:[ \t_-]+device[ \t_-]+id)?|world[ \t_-]+wide[ \t_-]+name))(\s*[:=]\s*)([^\r\n]*\S)/gi,
     (
       match: string,
       prefix: string,
@@ -299,8 +299,7 @@ const redactLabelledHardwareIds = (
       separator: string,
       rawValue: string,
     ) => {
-      const hexDigits = rawValue.replace(/[^A-Fa-f0-9]/g, "");
-      if (isPlaceholder(rawValue) || hexDigits.length < 16) {
+      if (isPlaceholder(rawValue.trim())) {
         return match;
       }
 
@@ -310,7 +309,7 @@ const redactLabelledHardwareIds = (
   );
 
   redacted = redacted.replace(
-    /(^|[^A-Za-z0-9_-])((?:serial(?:[ \t_-]+number)?|s\/n|sn))(\s*[:=]\s*)([A-Za-z0-9][A-Za-z0-9._-]{3,})/gi,
+    /(^|[^A-Za-z0-9_-])((?:(?:device[ \t_-]+)?serial(?:[ \t_-]+(?:number|no\.?))?|serialnumber|s\/n|sn))(\s*[:=]\s*)([^\r\n]*\S)/gi,
     (
       match: string,
       prefix: string,
@@ -318,7 +317,7 @@ const redactLabelledHardwareIds = (
       separator: string,
       rawValue: string,
     ) => {
-      if (isPlaceholder(rawValue)) {
+      if (isPlaceholder(rawValue.trim())) {
         return match;
       }
 
@@ -435,8 +434,27 @@ const isValidDomain = (candidate: string): boolean => {
   return labels !== undefined && labels.length >= 2;
 };
 
-const isValidLabelledHost = (candidate: string): boolean =>
-  domainLabels(candidate) !== undefined;
+const isValidLabelledHost = (candidate: string): boolean => {
+  const normalized = candidate.toLowerCase().replace(/\.$/, "");
+  if (
+    normalized.length === 0 ||
+    normalized.length > 253 ||
+    normalized.includes("..")
+  ) {
+    return false;
+  }
+
+  return normalized
+    .split(".")
+    .every(
+      (label) =>
+        label.length > 0 &&
+        label.length <= 63 &&
+        !label.startsWith("-") &&
+        !label.endsWith("-") &&
+        /^[a-z0-9_-]+$/.test(label),
+    );
+};
 
 const isLikelyDomain = (candidate: string): boolean => {
   const labels = domainLabels(candidate);
@@ -475,7 +493,7 @@ const redactDomains = (input: string, counts: MutableCounts): string => {
   );
 
   redacted = redacted.replace(
-    /(^|[^A-Za-z0-9_-])((?:domain|hostname|host|server))(\s*[:=]\s*)([A-Za-z0-9.-]+)/gi,
+    /(^|[^A-Za-z0-9_-])((?:domain|hostname|host[ \t_-]+name|computer[ \t_-]+name|node[ \t_-]+name|system[ \t_-]+name|host|server))(\s*[:=]\s*)([A-Za-z0-9][A-Za-z0-9._-]{0,252})/gi,
     (
       match: string,
       prefix: string,
diff --git a/schemas/README.md b/schemas/README.md
index 2c16394..6e86fda 100644
--- a/schemas/README.md
+++ b/schemas/README.md
@@ -16,6 +16,7 @@
 | [`incident-detective-share-card-v1.schema.json`](./incident-detective-share-card-v1.schema.json)                       | Score-only local SVG share data                        |
 | [`smart-rma-fixture-index-v1.schema.json`](./smart-rma-fixture-index-v1.schema.json)                                   | Fully synthetic smartctl fixture corpus                |
 | [`smart-rma-parse-result-v1.schema.json`](./smart-rma-parse-result-v1.schema.json)                                     | Browser-only structured SMART parse evidence           |
+| [`smart-rma-boundary-projection-v1.schema.json`](./smart-rma-boundary-projection-v1.schema.json)                       | Allowlisted SMART data for AI and export boundaries    |
 | [`ai-gateway-request-v1.schema.json`](./ai-gateway-request-v1.schema.json)                                             | Web-to-Gateway request envelope                        |
 | [`ai-gateway-response-v1.schema.json`](./ai-gateway-response-v1.schema.json)                                           | Validated Gateway result or safe error                 |
 
diff --git a/schemas/smart-rma-boundary-projection-v1.schema.json b/schemas/smart-rma-boundary-projection-v1.schema.json
new file mode 100644
index 0000000..e8a16cb
--- /dev/null
+++ b/schemas/smart-rma-boundary-projection-v1.schema.json
@@ -0,0 +1,304 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://lab.margrop.net/schemas/smart-rma-boundary-projection-v1.schema.json",
+  "title": "SMART / RMA Boundary Projection v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "parser_version",
+    "redactor_version",
+    "protocol",
+    "device_kind",
+    "smart_support",
+    "reported_overall_health",
+    "signals",
+    "missing_fields",
+    "temperature_celsius",
+    "power_on_hours",
+    "ata",
+    "nvme",
+    "privacy"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "1.0"
+    },
+    "parser_version": {
+      "const": "1.0"
+    },
+    "redactor_version": {
+      "const": "1.0"
+    },
+    "protocol": {
+      "enum": ["ata", "nvme", "unknown"]
+    },
+    "device_kind": {
+      "enum": ["hdd", "ssd", "nvme", "unknown"]
+    },
+    "smart_support": {
+      "enum": ["available", "unavailable", "unknown"]
+    },
+    "reported_overall_health": {
+      "enum": ["passed", "failed", "unknown"]
+    },
+    "signals": {
+      "type": "array",
+      "maxItems": 13,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/signal"
+      }
+    },
+    "missing_fields": {
+      "type": "array",
+      "maxItems": 6,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/missingField"
+      }
+    },
+    "temperature_celsius": {
+      "$ref": "#/$defs/nullableMetric"
+    },
+    "power_on_hours": {
+      "$ref": "#/$defs/nullableCounter"
+    },
+    "ata": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["attributes", "error_count", "self_test_failure_count"],
+      "properties": {
+        "attributes": {
+          "type": "array",
+          "maxItems": 128,
+          "items": {
+            "$ref": "#/$defs/ataAttribute"
+          }
+        },
+        "error_count": {
+          "$ref": "#/$defs/nullableCounter"
+        },
+        "self_test_failure_count": {
+          "$ref": "#/$defs/counter"
+        }
+      }
+    },
+    "nvme": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "critical_warning",
+        "available_spare_percent",
+        "available_spare_threshold_percent",
+        "percentage_used",
+        "media_errors",
+        "error_log_entries"
+      ],
+      "properties": {
+        "critical_warning": {
+          "anyOf": [
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 255
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "available_spare_percent": {
+          "$ref": "#/$defs/nullablePercent"
+        },
+        "available_spare_threshold_percent": {
+          "$ref": "#/$defs/nullablePercent"
+        },
+        "percentage_used": {
+          "$ref": "#/$defs/nullablePercent"
+        },
+        "media_errors": {
+          "$ref": "#/$defs/nullableCounter"
+        },
+        "error_log_entries": {
+          "$ref": "#/$defs/nullableCounter"
+        }
+      }
+    },
+    "privacy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["redactions_total", "counts"],
+      "properties": {
+        "redactions_total": {
+          "$ref": "#/$defs/counter"
+        },
+        "counts": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "authorization",
+            "cookie",
+            "token",
+            "email",
+            "ip",
+            "domain",
+            "serial_number",
+            "wwn"
+          ],
+          "properties": {
+            "authorization": {
+              "$ref": "#/$defs/counter"
+            },
+            "cookie": {
+              "$ref": "#/$defs/counter"
+            },
+            "token": {
+              "$ref": "#/$defs/counter"
+            },
+            "email": {
+              "$ref": "#/$defs/counter"
+            },
+            "ip": {
+              "$ref": "#/$defs/counter"
+            },
+            "domain": {
+              "$ref": "#/$defs/counter"
+            },
+            "serial_number": {
+              "$ref": "#/$defs/counter"
+            },
+            "wwn": {
+              "$ref": "#/$defs/counter"
+            }
+          }
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "protocol": {
+            "const": "nvme"
+          }
+        },
+        "required": ["protocol"]
+      },
+      "then": {
+        "properties": {
+          "device_kind": {
+            "const": "nvme"
+          }
+        }
+      }
+    }
+  ],
+  "$defs": {
+    "counter": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "nullableCounter": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/counter"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "nullableMetric": {
+      "anyOf": [
+        {
+          "type": "integer",
+          "minimum": -100,
+          "maximum": 500
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "nullablePercent": {
+      "anyOf": [
+        {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100000
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "signal": {
+      "enum": [
+        "smart-overall-passed",
+        "smart-overall-failed",
+        "ata-reallocated-sectors",
+        "ata-pending-sectors",
+        "ata-uncorrectable-sectors",
+        "ata-error-log",
+        "nvme-critical-warning",
+        "nvme-spare-below-threshold",
+        "nvme-percentage-used",
+        "nvme-media-errors",
+        "vendor-extension",
+        "smart-unavailable",
+        "incomplete-identification"
+      ]
+    },
+    "missingField": {
+      "enum": [
+        "model",
+        "serial_number",
+        "firmware_version",
+        "overall_health",
+        "temperature",
+        "power_on_hours"
+      ]
+    },
+    "ataAttribute": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "normalized_value",
+        "worst_value",
+        "threshold",
+        "when_failed",
+        "raw_value"
+      ],
+      "properties": {
+        "id": {
+          "enum": [5, 9, 187, 194, 197, 198]
+        },
+        "normalized_value": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "worst_value": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "threshold": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "when_failed": {
+          "type": "boolean"
+        },
+        "raw_value": {
+          "$ref": "#/$defs/nullableCounter"
+        }
+      }
+    }
+  }
+}