# Income Budget Report Native (Group A) — Remediation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Fix the Critical/Important defects found by the final whole-branch review of `docs/superpowers/plans/2026-08-05-income-budget-report-native-group-a.md` (both the backend and frontend halves), and close the scope gaps the human explicitly approved fixing now rather than deferring: (1) seed *every* editable amount field so nothing is silently dropped, (2) source ร.4/ร.5 (`invest_asset_request_information`/`invest_construct_request_information`) into the native tree so the "ค่าครุภัณฑ์"/"ค่าที่ดินและสิ่งก่อสร้าง" leaf-tables aren't permanently empty, (3) generate a real government-form-styled `.xlsx` export instead of a flat 2-column dump, and (4) dual-write type-1 drafts into `revenue_draft_committee` so type-2's picker and the report list keep working end to end, with legacy pre-existing rows still reachable.

**Architecture:** Continues directly on the two existing worktrees/branches from the Group A plan (do not create new worktrees — this is a fix-forward continuation of `worktree-income-budget-report-api` in both `rmutr-api` and `rmutr-web`). No new tables. Extends `income_budget_report` with one nullable link column, extends `IncomeBudgetReportService.CreateDraft` to seed every schema-defined line (not just personnel ones) and to mirror a `revenue_draft_committee` row, replaces the flat xlsx exporter with a structured one, and extends the frontend list/edit flow to union native + legacy data sources.

**Tech Stack:** ASP.NET Core 8 / EF Core 8 / Npgsql (manual SQL migrations only — no `dotnet ef migrations add`), EPPlus 6.2.4, Angular / RxJS, PostgreSQL (`"BUDGET"` schema).

## Global Constraints

- Manual SQL migrations only, in `rmutr-api/Migrations/*.sql`, applied directly to production Postgres (`rmutr_budget_050625` at `203.158.221.28:31620`) via `psql`. `dotnet ef migrations add` is forbidden in this codebase (pre-existing unrelated EF migration-history drift).
- No automated test framework exists in either repo. Every task's verification step is a concrete manual check (`dotnet build`, `psql` query, `curl`, or browser check) — run it and read the actual output before moving on.
- All monetary fields end in `_amount` or `_price` so the project-wide `OnModelCreating` convention (`rmutr-api/Databases/Features/Db.cs:91-99`) automatically applies `numeric(18,4)` precision — do not set precision manually. `income_budget_report_line.amount`/`original_amount` are already plain `numeric` columns per the approved Task-3 deviation from the original plan — do not change their SQL type.
- **EF Core `t_`/`v_` FK gotcha:** when adding a relationship between two entities that have `t_`/`v_` write/read-view variants, `HasOne/WithMany/HasForeignKey` must be configured on BOTH the `t_` and `v_` sides in `Db.cs`, or EF creates a broken shadow FK causing a runtime 500. This plan avoids the gotcha entirely by adding only plain scalar `Guid?` columns (no navigation properties) — do not add navigation properties for `income_budget_report.revenue_draft_committee_uid`.
- DI registration for every new service must go in a `Modules/<Module>/Configures/<Module>.cs` file using the `public static class XxxCollectionExtension { public static IServiceCollection AddXxxServices(this IServiceCollection services) { ... return services; } }` pattern, invoked from `Startup.cs`'s service-registration block (around lines 155-183). This is how every other module in the codebase registers its services — `IncomeBudgetReportService` currently has no such file, which is Task 1 of this plan.
- Newtonsoft.Json via `AddNewtonsoftJson()` with no camelCase policy — new DTO properties consumed by the frontend need explicit `[JsonProperty("camelCaseName")]` attributes, exactly like `Modules/IncomeBudgetReport/Config/ReportTreeNode.cs` already does.
- Frontend error handling convention for HTTP calls in this component: `catchError(err => { Swal.fire(err.error.description, '', 'error'); return throwError(err); })`, matching `saveComplete()` in `income-budget-report.component.ts`. Use this pattern for every new `.subscribe()` this plan adds to that file.
- `Helper.GetDataFilter(identity, new List<string>{"agency_uid"})` (external `SeventyOneDev.Utilities` package, no local source) returns the caller's agency uid(s) as `List<Guid?>`; empty list = unrestricted. Existing convention: `.Where(a => a != Guid.Empty).ToList()` before using it as a filter.
- Types 2-10 must remain byte-for-byte behaviorally unchanged by this plan — every task that touches shared files (`income-budget-report.component.ts`, `income-budget-report-list.component.ts`) must be additive/branching only, never modifying the existing type 2-10 code paths.

---

## File Map

**Backend (`rmutr-api/.claude/worktrees/income-budget-report-api`):**
- Create: `Modules/IncomeBudgetReport/Configures/IncomeBudgetReport.cs` — DI registration (Task 1)
- Create: `Migrations/add_income_budget_report_remediation.sql` — unique index, link column (Task 2)
- Modify: `Modules/IncomeBudgetReport/Databases/Models/income_budget_report/income_budget_report.cs` — add `revenue_draft_committee_uid` scalar (Task 2)
- Modify: `Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs` — seed all lines, owner_agency_uid stamping, dual-write (Tasks 3, 4, 5, 8)
- Modify: `Modules/IncomeBudgetReport/Config/IncomeReportTreeSchema.cs` — leaf-amount key list + output-label matcher (Tasks 3, 4)
- Modify: `Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs` — ownership guard on `PUT lines`, new exporter (Tasks 6, 7)
- Create: `Modules/IncomeBudgetReport/Services/IncomeBudgetReportXlsxExporter.cs` — structured export (Task 7)

**Frontend (`rmutr-web/.claude/worktrees/income-budget-report-api`):**
- Modify: `src/app/feature/income/draft/income-budget-report1/income-budget-report1-list/income-budget-report-list.component.ts` — union legacy rows (Task 9)
- Modify: `src/app/feature/income/draft/income-budget-report1/income-budget-report1/income-budget-report.component.ts` — legacy-edit branch, error/loading handling, pendingChanges reset (Task 10)
- Modify: `src/app/shared/components/budget-report-tree/budget-report-tree-node.component.ts`/`.html`/`.scss` — decimal-input fix, indentation fix (Task 10)

---

### Task 1: Register `IncomeBudgetReportService` in DI

**Files:**
- Create: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Configures/IncomeBudgetReport.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Startup.cs`

**Why this is Critical:** `IncomeBudgetReportController`'s constructor takes `IncomeBudgetReportService` by concrete type. No `Configures/*.cs` file exists for this module and `Startup.cs` never calls an `AddIncomeBudgetReportServices()`. Every request to any endpoint on this controller — including the inherited `BaseUidController` CRUD/list routes the frontend list page depends on — throws `InvalidOperationException: Unable to resolve service for type 'IncomeBudgetReportService'` and 500s. This was never caught because the plan had no DI-registration verification step and Task 8's swagger-based check only enumerates routes, never activates the controller.

**Interfaces:**
- Consumes: `IncomeBudgetReportService` (existing, `Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs`)
- Produces: nothing new consumed by later tasks — this just makes the existing controller constructible.

- [ ] **Step 1: Create the Configures file**

```csharp
using Microsoft.Extensions.DependencyInjection;
using rmutr_budget_api.Modules.IncomeBudgetReport.Services;

namespace rmutr_budget_api.Modules.IncomeBudgetReport.Configures
{
    public static class IncomeBudgetReportCollectionExtension
    {
        public static IServiceCollection AddIncomeBudgetReportServices(this IServiceCollection services)
        {
            services.AddScoped<IncomeBudgetReportService>();
            return services;
        }
    }
}
```

- [ ] **Step 2: Register it in Startup.cs**

Open `Startup.cs`, find the block of `services.AddXxxServices();` calls (around line 155-183, ends with `services.AddPlanResultServices();`). Add a new line immediately after it:

```csharp
services.AddPlanResultServices();
services.AddIncomeBudgetReportServices();
```

Add the using statement at the top of `Startup.cs` alongside the other `Modules.*.Configures` usings:

```csharp
using rmutr_budget_api.Modules.IncomeBudgetReport.Configures;
```

- [ ] **Step 3: Build and verify by actually calling the endpoint, not swagger**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`.

Then start the API locally (or use whatever run command the rest of this worktree's task reports used — check `.superpowers/sdd/2026-08-05-income-budget-report-native-group-a/task-8-report.md` for the exact local-run command) and hit the endpoint directly:
```bash
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:<port>/api/setting/income_budget_report/agency?type_id=1
```
Expected: `401` (Unauthorized — no token supplied) or `200`, **not** `500`. A `500` here means DI is still broken; a `401` proves the controller was constructed successfully (DI resolved) and only the `[Authorize]` check rejected the anonymous request, which is correct.

- [ ] **Step 4: Commit**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
git add Modules/IncomeBudgetReport/Configures/IncomeBudgetReport.cs Startup.cs
git commit -m "fix: register IncomeBudgetReportService in DI (every endpoint was 500ing)"
```

---

### Task 2: Migration — duplicate-draft unique index + dual-write link column

**Files:**
- Create: `rmutr-api/.claude/worktrees/income-budget-report-api/Migrations/add_income_budget_report_remediation.sql`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Databases/Models/income_budget_report/income_budget_report.cs`

**Why:** (1) `CreateDraft`'s existing check-then-insert duplicate-draft guard has no backing constraint — a double-click still creates two drafts (this is the exact bug that triggered a Task-5 reopen during the original plan; a partial unique index closes it for good and also gives the lookup an index it currently lacks). (2) Task 8 (dual-write) needs a place to record which `revenue_draft_committee` row mirrors a given `income_budget_report` row.

**Interfaces:**
- Produces: `income_budget_report.revenue_draft_committee_uid : Guid?`, consumed by Task 8 (dual-write) and Task 9 (frontend list union, to dedupe legacy rows).

- [ ] **Step 1: Write the migration**

```sql
-- Migration: Remediation for income_budget_report (Group A native report).
-- Date: 2026-08-05
-- Description: (1) Partial unique index preventing duplicate type-1 drafts per personnel_statement_uid
--              (closes a known TOCTOU race in CreateDraft's check-then-insert guard).
--              (2) revenue_draft_committee_uid link column for the dual-write mirror
--              (see IncomeBudgetReportService.CreateDraft / SyncMirror).
--              Idempotent: safe to run again.

CREATE UNIQUE INDEX IF NOT EXISTS "UX_income_budget_report_personnel_statement_uid_type1"
    ON "BUDGET".income_budget_report (personnel_statement_uid)
    WHERE type_id = 1;

ALTER TABLE "BUDGET".income_budget_report
    ADD COLUMN IF NOT EXISTS revenue_draft_committee_uid uuid;

CREATE OR REPLACE VIEW "BUDGET".v_income_budget_report AS
SELECT * FROM "BUDGET".income_budget_report;
```

- [ ] **Step 2: Apply it to production**

```bash
PGPASSWORD='vtwi,yo0tpkd-okfouh' psql -h 203.158.221.28 -p 31620 -U devadmin -d rmutr_budget_050625 \
  -f /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api/Migrations/add_income_budget_report_remediation.sql
```
If the VPN to `203.158.221.28` is down, ask the human to reconnect before running this (established pattern from the rest of this session).

Verify:
```bash
PGPASSWORD='vtwi,yo0tpkd-okfouh' psql -h 203.158.221.28 -p 31620 -U devadmin -d rmutr_budget_050625 \
  -c "\d \"BUDGET\".income_budget_report"
```
Expected: `revenue_draft_committee_uid` listed as a column, and `UX_income_budget_report_personnel_statement_uid_type1` listed as an index.

- [ ] **Step 3: Add the matching C# property**

In `income_budget_report.cs`, add the field to the base class (so both `t_income_budget_report` and `v_income_budget_report` inherit it — no navigation property, plain scalar, no FK gotcha):

```csharp
        public Guid? parent_uid { get; set; }
        public Guid? personnel_statement_uid { get; set; }
        public Guid? revenue_draft_committee_uid { get; set; }
```
(insert the new line directly after the existing `personnel_statement_uid` line)

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`.

- [ ] **Step 5: Commit**

```bash
git add Migrations/add_income_budget_report_remediation.sql Modules/IncomeBudgetReport/Databases/Models/income_budget_report/income_budget_report.cs
git commit -m "feat: add duplicate-draft unique index and revenue_draft_committee link column"
```

---

### Task 3: Seed every leaf-amount line (fixes the silent data-loss bug)

**Files:**
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Config/IncomeReportTreeSchema.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs`

**Why this is Critical:** `CreateDraft` only ever creates lines for `node_key = "pb-temp-old"`/`"pb-temp-new"` (personnel sources). The other 13 `leaf-amount` nodes in the schema (`pb-cola-old`, `pb-cola-new`, `op-comp`, and `{out1..out5}-grant-proj`/`{out1..out5}-other`) have no backing line at all. `BuildNode` renders them as editable (`Locked = false`, `LineUid = null`) because there's no line to lock, but every edit collides on the same `null` key client-side and the backend silently skips a `null`-keyed line-uid update. **Not a single one of these 13 fields can currently be saved.** The design spec (`docs/superpowers/specs/2026-08-05-income-budget-report-native-design.md:77`) explicitly describes this case — "รายการที่ `source_uid = null`... แก้ไขได้ทั้งชื่อและจำนวนเงิน" (source_uid=null items are editable) — meaning these rows were always meant to exist with `source_uid = null`, `source_type = "manual"`; `CreateDraft` simply never created them.

**Interfaces:**
- Produces: `IncomeReportTreeSchema.CollectLeafAmountKeys() : List<(string NodeKey, string Label)>`, consumed by `CreateDraft` in this task.

- [ ] **Step 1: Add a leaf-amount key collector to the schema**

In `IncomeReportTreeSchema.cs`, add this method to the `IncomeReportTreeSchema` static class (after `ForType1()`):

```csharp
        /// Every "leaf-amount" node key + label in the type-1 tree, in document order.
        /// Used by CreateDraft to seed a zero-amount manual line for each one, so every
        /// editable field has a real income_budget_report_line row to save against.
        public static List<(string NodeKey, string Label)> CollectLeafAmountKeys()
        {
            var result = new List<(string, string)>();
            CollectLeafAmountKeysRecursive(ForType1(), result);
            return result;
        }

        private static void CollectLeafAmountKeysRecursive(ReportTreeNodeDef def, List<(string, string)> result)
        {
            if (def.Kind == "leaf-amount")
            {
                result.Add((def.NodeKey, def.Label));
                return;
            }
            foreach (var child in def.Children)
            {
                CollectLeafAmountKeysRecursive(child, result);
            }
        }
```

- [ ] **Step 2: Seed a manual line for every leaf-amount key in `CreateDraft`**

In `IncomeBudgetReportService.cs`, inside `CreateDraft`, after the existing `foreach (var d in statement.personnel_statement_details_2 ...)` block and before `await _context.t_income_budget_report.AddAsync(report);`, add:

```csharp
            foreach (var (nodeKey, label) in IncomeReportTreeSchema.CollectLeafAmountKeys())
            {
                lines.Add(new t_income_budget_report_line
                {
                    income_budget_report_line_uid = Guid.NewGuid(),
                    income_budget_report_uid = reportUid,
                    node_key = nodeKey,
                    source_type = "manual",
                    source_uid = null,
                    label_th = label,
                    qualification_th = null,
                    qty = null,
                    amount = 0,
                    original_amount = 0,
                    sequence_no = seq++,
                });
            }
```

This must run unconditionally (not gated on `statement != null`) — the leaf-amount fields aren't personnel-sourced, so a report should always get them.

- [ ] **Step 3: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`.

- [ ] **Step 4: Verify against a real draft**

Pick a real `personnel_statement_uid` from production (or ask the human which one is safe to use for testing), call:
```bash
curl -s -X POST "http://localhost:<port>/api/setting/income_budget_report/create_draft?personnel_statement_uid=<uid>" \
  -H "Authorization: Bearer <token>" | jq '.income_budget_report_lines | length, ([.[] | select(.source_type == "manual")] | length)'
```
Expected: the manual-line count is exactly `13`. Then `GET .../{uid}/tree` and confirm `pb-cola-old`, `pb-cola-new`, `op-comp`, and every `out{N}-grant-proj`/`out{N}-other` node has `"locked": false` and a non-null `"lineUid"`.

- [ ] **Step 5: Commit**

```bash
git add Modules/IncomeBudgetReport/Config/IncomeReportTreeSchema.cs Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs
git commit -m "fix: seed manual lines for every leaf-amount node (13 fields could not be saved before)"
```

---

### Task 4: Wire ร.4/ร.5 (invest_asset/invest_construct) into the leaf-table nodes

**Files:**
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Config/IncomeReportTreeSchema.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs`

**Why:** The type-1 schema has 10 `leaf-table` nodes (`{out1..out5}-invest-equip`/`{out1..out5}-invest-land`) meant to hold ร.4 (`invest_asset_request_information`)/ร.5 (`invest_construct_request_information`) rows for that output ("ผลผลิต"). `CreateDraft` never queries either table, so these always render `"ยังไม่มีรายการ"`. The human explicitly approved wiring this in now rather than deferring it.

**Grouping approach:** `invest_asset_request_information`/`invest_construct_request_information` don't carry a `node_key` — they're matched to an output node by their `budget_project_name_th` (the "ผลผลิต" name), compared against the schema's own `out1`..`out5` group labels (which are the real ผลผลิต names, verified against production — see `IncomeReportTreeSchema.cs:43-51`). A row whose `budget_project_name_th` doesn't match any of the 5 output labels is skipped (logged, not silently discarded — see Step 3) rather than guessed at, since there is no existing convention in this codebase for approval-status filtering on these two tables (confirmed: `BudgetProgressService.GetSummaryExpense` doesn't filter on `is_approve` either) and inventing one here would be a new, undiscussed policy.

**Interfaces:**
- Consumes: `invest_asset_request_information`/`invest_construct_request_information` — read via `Db` directly (`_context.v_invest_asset_request_information`, `_context.v_invest_construct_request_information`), filtered `budget_year_uid == statement.budget_year_uid` (the report's own budget year — there is no `faculty_uid` on `personnel_statement` to filter by, matching the already-approved Task-5 precedent of not having a faculty filter for this report; filtering by `budget_year_uid` alone mirrors `BudgetProgressService.GetSummaryExpense`'s scoping intent as closely as this report's available data allows).
- Produces: `IncomeReportTreeSchema.OutputPrefixByLabel() : Dictionary<string, string>`, consumed by `CreateDraft`.

- [ ] **Step 1: Add an output-label-to-prefix lookup to the schema**

In `IncomeReportTreeSchema.cs`, add (after `CollectLeafAmountKeys`):

```csharp
        /// Maps each "ผลผลิต" (output) label to its node-key prefix ("out1".."out5"), so
        /// CreateDraft can match invest_asset/invest_construct rows (which carry a
        /// budget_project_name_th, not a node_key) to the correct leaf-table node.
        public static Dictionary<string, string> OutputPrefixByLabel()
        {
            var result = new Dictionary<string, string>();
            CollectOutputPrefixesRecursive(ForType1(), result);
            return result;
        }

        private static void CollectOutputPrefixesRecursive(ReportTreeNodeDef def, Dictionary<string, string> result)
        {
            if (def.Kind == "group" && def.NodeKey.StartsWith("out") && def.NodeKey.Length <= 4)
            {
                result[def.Label.Trim()] = def.NodeKey;
            }
            foreach (var child in def.Children)
            {
                CollectOutputPrefixesRecursive(child, result);
            }
        }
```

(`def.NodeKey.Length <= 4` excludes `out1-grant`/`out1-invest` etc., matching only the top-level `out1`..`out5` group nodes themselves.)

- [ ] **Step 2: Query and map invest rows in `CreateDraft`**

In `IncomeBudgetReportService.cs`, `CreateDraft`, immediately after the leaf-amount seeding loop added in Task 3 and still before `await _context.t_income_budget_report.AddAsync(report);`, add:

```csharp
            var outputPrefixByLabel = IncomeReportTreeSchema.OutputPrefixByLabel();
            var unmatchedInvestLabels = new List<string>();

            if (statement?.budget_year_uid != null)
            {
                var assetRows = await _context.v_invest_asset_request_information
                    .Where(c => c.budget_year_uid == statement.budget_year_uid)
                    .ToListAsync();
                foreach (var a in assetRows)
                {
                    var label = a.budget_project_name_th?.Trim();
                    if (label == null || !outputPrefixByLabel.TryGetValue(label, out var prefix))
                    {
                        if (label != null) unmatchedInvestLabels.Add($"invest_asset:{label}");
                        continue;
                    }
                    lines.Add(new t_income_budget_report_line
                    {
                        income_budget_report_line_uid = Guid.NewGuid(),
                        income_budget_report_uid = reportUid,
                        node_key = $"{prefix}-invest-equip",
                        source_type = "invest_asset",
                        source_uid = a.invest_asset_request_information_uid,
                        label_th = a.invest_asset_request_information_name_th,
                        qualification_th = null,
                        qty = a.amount_unit,
                        amount = a.total_unit_price ?? 0,
                        original_amount = a.total_unit_price ?? 0,
                        sequence_no = seq++,
                    });
                }

                var constructRows = await _context.v_invest_construct_request_information
                    .Where(c => c.budget_year_uid == statement.budget_year_uid)
                    .ToListAsync();
                foreach (var c in constructRows)
                {
                    var label = c.budget_project_name_th?.Trim();
                    if (label == null || !outputPrefixByLabel.TryGetValue(label, out var prefix))
                    {
                        if (label != null) unmatchedInvestLabels.Add($"invest_construct:{label}");
                        continue;
                    }
                    lines.Add(new t_income_budget_report_line
                    {
                        income_budget_report_line_uid = Guid.NewGuid(),
                        income_budget_report_uid = reportUid,
                        node_key = $"{prefix}-invest-land",
                        source_type = "invest_construct",
                        source_uid = c.invest_construct_request_information_uid,
                        label_th = c.invest_construct_request_information_name_th,
                        qualification_th = null,
                        qty = null,
                        amount = c.budget ?? 0,
                        original_amount = c.budget ?? 0,
                        sequence_no = seq++,
                    });
                }
            }
```

- [ ] **Step 3: Surface unmatched rows instead of silently dropping them**

Still in `CreateDraft`, after building `report` but before `return await GetEntity(reportUid);`, log unmatched labels so a mismatch (e.g. a ผลผลิต name that drifted since the schema was verified against production) is visible in logs rather than invisible:

```csharp
            if (unmatchedInvestLabels.Any())
            {
                Console.WriteLine($"[IncomeBudgetReportService.CreateDraft] {unmatchedInvestLabels.Count} invest row(s) did not match any output label and were skipped: {string.Join(", ", unmatchedInvestLabels.Distinct())}");
            }
```

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`. If `v_invest_asset_request_information`/`v_invest_construct_request_information` aren't already `DbSet`-exposed on `Db`, this step will fail with a compile error naming the missing property — if that happens, find the exact `DbSet<v_invest_asset_request_information>` / `DbSet<v_invest_construct_request_information>` property names already declared in `Modules/InvestInformations/Databases/Db.cs` (or wherever they're registered) and use those exact names/casing.

- [ ] **Step 5: Verify against a real budget year with known invest rows**

```bash
curl -s -X POST "http://localhost:<port>/api/setting/income_budget_report/create_draft?personnel_statement_uid=<uid>" \
  -H "Authorization: Bearer <token>" > /tmp/draft.json
curl -s "http://localhost:<port>/api/setting/income_budget_report/$(jq -r .income_budget_report_uid /tmp/draft.json)/tree" \
  -H "Authorization: Bearer <token>" | jq '.. | objects | select(.nodeKey? | test("invest")) | {nodeKey, rows: (.rows | length)}'
```
Expected: at least one `*-invest-equip`/`*-invest-land` node has `rows > 0` for a faculty/year known to have ร.4/ร.5 data (ask the human which `budget_year_uid` has real data if unsure, or check `check-pa-status.md`/similar files from earlier investigation in the outer repo for a known-good example).

- [ ] **Step 6: Commit**

```bash
git add Modules/IncomeBudgetReport/Config/IncomeReportTreeSchema.cs Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs
git commit -m "feat: source invest_asset/invest_construct (ร.4/ร.5) into the leaf-table nodes"
```

---

### Task 5: Agency-ownership guard on `PUT lines`, and reject writes to locked lines

**Files:**
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs`

**Why:** `PUT .../lines` currently looks up each line by bare uid and overwrites it with no check that the line's report belongs to the caller's agency, and no check on `source_uid` — the UI-only `locked` flag can be bypassed entirely via direct API call, letting any authenticated user rewrite any faculty's report, including authoritative ร.2/ร.4/ร.5-sourced figures. There is no existing precedent in this codebase for a write-time ownership guard (confirmed — every `Helper.GetDataFilter` usage is either a read-list filter or a create-time stamp), so this task also has to make `CreateDraft`/`CloneNextRound` actually stamp `owner_agency_uid` (currently unset on both), since the guard needs something real to check.

**Interfaces:**
- Consumes: `Helper.GetDataFilter(ClaimsIdentity, List<string>)` (external package, existing convention).
- Produces: `UpdateLineAmounts` now returns `400 BadRequest` with a description when a line is rejected, instead of silently succeeding.

- [ ] **Step 1: Stamp `owner_agency_uid` in `CreateDraft` and `CloneNextRound`**

In `IncomeBudgetReportService.cs`, `CreateDraft`, add to the `report` object initializer (right after `status_id = 0,`):

```csharp
                status_id = 0,
                owner_agency_uid = Helper.GetDataFilter(identity, new List<string> { "agency_uid" }).Where(a => a != Guid.Empty).FirstOrDefault(),
```

Do the same in `CloneNextRound`'s `clone` object initializer:

```csharp
                status_id = 0,
                owner_agency_uid = Helper.GetDataFilter(identity, new List<string> { "agency_uid" }).Where(a => a != Guid.Empty).FirstOrDefault(),
```

(`Helper` is already in scope via `using SeventyOneDev.Utilities;` at the top of the file.)

- [ ] **Step 2: Add a guarded update method to the service**

In `IncomeBudgetReportService.cs`, add a new public method (after `CloneNextRound`, before `BuildTree`):

```csharp
        public async Task<List<string>> UpdateLineAmounts(List<(Guid LineUid, decimal Amount)> updates, ClaimsIdentity identity)
        {
            var agencies = Helper.GetDataFilter(identity, new List<string> { "agency_uid" }).Where(a => a != Guid.Empty).ToList();
            var rejected = new List<string>();

            foreach (var (lineUid, amount) in updates)
            {
                var line = await _context.t_income_budget_report_line.FindAsync(lineUid);
                if (line == null)
                {
                    rejected.Add($"{lineUid}: ไม่พบรายการ");
                    continue;
                }
                if (line.source_uid != null)
                {
                    rejected.Add($"{lineUid}: รายการนี้ล็อกไว้ แก้ไขไม่ได้");
                    continue;
                }
                var report = await _context.t_income_budget_report.FindAsync(line.income_budget_report_uid);
                if (report == null || (agencies.Any() && !agencies.Contains(report.owner_agency_uid)))
                {
                    rejected.Add($"{lineUid}: ไม่มีสิทธิ์แก้ไขรายงานนี้");
                    continue;
                }
                line.amount = amount;
            }

            await _context.SaveChangesAsync(identity);
            return rejected;
        }
```

- [ ] **Step 3: Use it from the controller instead of the inline `_db` loop**

In `IncomeBudgetReportController.cs`, replace the entire `UpdateLineAmounts` action body:

```csharp
        [Authorize]
        [HttpPut("lines")]
        public async Task<ActionResult> UpdateLineAmounts([FromBody] List<LineAmountUpdate> updates)
        {
            var rejected = await _service.UpdateLineAmounts(
                updates.Select(u => (u.income_budget_report_line_uid, u.amount)).ToList(),
                User.Identity as ClaimsIdentity);
            if (rejected.Any())
            {
                return BadRequest(new { description = string.Join("; ", rejected) });
            }
            return Ok();
        }
```

Add `using System.Linq;` to the top of the controller file if not already present (it is not, per the file read earlier).

The `_db` field and its constructor parameter are no longer used by this action, but leave them in place — `Db db` may still be needed if other actions in this controller are added later, and removing it isn't required by this fix.

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`.

- [ ] **Step 5: Verify the guard rejects a locked-line write**

```bash
curl -s -X PUT "http://localhost:<port>/api/setting/income_budget_report/lines" \
  -H "Authorization: Bearer <token>" -H "Content-Type: application/json" \
  -d '[{"income_budget_report_line_uid":"<a locked personnel line uid from GET .../tree>","amount":999999}]'
```
Expected: `400` with a description containing "ล็อกไว้". Then repeat with a real unlocked manual line's uid (from Task 3's seeded lines) and confirm `200 OK` and that the amount actually changed on a follow-up `GET .../tree`.

- [ ] **Step 6: Commit**

```bash
git add Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs
git commit -m "fix: guard PUT lines against cross-agency writes and locked-line edits"
```

---

### Task 6: Structured xlsx export matching the official form's shape

**Files:**
- Create: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Services/IncomeBudgetReportXlsxExporter.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs`

**Why:** The current export (`WriteNode`) is a flat 2-column `label`/`amount` dump with space-indentation — nothing like the real government form. **No literal `.xlsx` template file exists anywhere reachable from this codebase** (confirmed: the real form is rendered by a separate paid FastReport microservice, `rmutr_report`, using `.frx` templates that cannot be loaded by EPPlus; the production blank-template URL the old SyncFusion UI used is currently returning `503`). Per the human's explicit decision, this task builds a **new, EPPlus-constructed workbook that replicates the government form's structure** (title block, indented tree with real merged/bordered cells, right-aligned currency, signature block) using the schema's own hierarchy and labels — not a pixel-identical reproduction of the FastReport output. This must be reviewed against the real form by a human before this feature is considered fully production-ready for actual government submission (flag this explicitly in the task's completion report).

**Interfaces:**
- Consumes: `ReportTreeNode` (existing, `Modules/IncomeBudgetReport/Config/ReportTreeNode.cs`), `v_income_budget_report` (for header fields: `sector_name_th`, `budget_year_uid` — resolve the year's display name via `_context.v_budget_year`).
- Produces: `IncomeBudgetReportXlsxExporter.Build(v_income_budget_report report, ReportTreeNode tree, string budgetYearNameTh, string personnelStatementDisplayName) : byte[]`, consumed by the controller (this task) and by Task 8 (dual-write, server-side generation).

- [ ] **Step 1: Write the exporter**

```csharp
using System.Linq;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using rmutr_budget_api.Modules.IncomeBudgetReport.Config;
using rmutr_budget_api.Modules.IncomeBudgetReport.Databases.Models;

namespace rmutr_budget_api.Modules.IncomeBudgetReport.Services
{
    public static class IncomeBudgetReportXlsxExporter
    {
        public static byte[] Build(v_income_budget_report report, ReportTreeNode tree, string budgetYearNameTh, string personnelStatementDisplayName)
        {
            ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
            using var package = new ExcelPackage();
            var ws = package.Workbook.Worksheets.Add("Page1");

            ws.Column(1).Width = 55;
            ws.Column(2).Width = 20;
            ws.Column(3).Width = 12;
            ws.Column(4).Width = 18;

            ws.Cells["A1:D1"].Merge = true;
            ws.Cells["A1"].Value = "ร่างเงินรายได้ เพื่อประชุมคณะกรรมการร่างเงินรายได้";
            ws.Cells["A1"].Style.Font.Bold = true;
            ws.Cells["A1"].Style.Font.Size = 14;
            ws.Cells["A1"].Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;

            ws.Cells["A2:D2"].Merge = true;
            ws.Cells["A2"].Value = $"หน่วยงาน: {personnelStatementDisplayName}    ปีงบประมาณ: {budgetYearNameTh}";
            ws.Cells["A2"].Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;

            int headerRow = 4;
            ws.Cells[headerRow, 1].Value = "รายการ";
            ws.Cells[headerRow, 2].Value = "อัตรา/วุฒิ";
            ws.Cells[headerRow, 3].Value = "จำนวน";
            ws.Cells[headerRow, 4].Value = "จำนวนเงิน (บาท)";
            using (var headerRange = ws.Cells[headerRow, 1, headerRow, 4])
            {
                headerRange.Style.Font.Bold = true;
                headerRange.Style.Fill.PatternType = ExcelFillStyle.Solid;
                headerRange.Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                headerRange.Style.Border.BorderAround(ExcelBorderStyle.Thin);
            }

            int row = headerRow + 1;
            WriteNode(tree, ws, ref row);

            using (var dataRange = ws.Cells[headerRow, 1, row - 1, 4])
            {
                dataRange.Style.Border.Top.Style = ExcelBorderStyle.Thin;
                dataRange.Style.Border.Bottom.Style = ExcelBorderStyle.Thin;
                dataRange.Style.Border.Left.Style = ExcelBorderStyle.Thin;
                dataRange.Style.Border.Right.Style = ExcelBorderStyle.Thin;
            }

            row += 3;
            ws.Cells[row, 1].Value = "ลงชื่อ .............................................. ผู้จัดทำ";
            row += 2;
            ws.Cells[row, 1].Value = "ลงชื่อ .............................................. ประธานคณะกรรมการร่างเงินรายได้";
            row += 2;
            ws.Cells[row, 1].Value = "วันที่ .............../.............../...............";

            ws.View.FreezePanes(headerRow + 1, 1);

            return package.GetAsByteArray();
        }

        private static void WriteNode(ReportTreeNode node, ExcelWorksheet ws, ref int row)
        {
            var cell = ws.Cells[row, 1];
            cell.Value = node.Label;
            cell.Style.Indent = node.Depth;
            if (node.Kind == "group")
            {
                cell.Style.Font.Bold = true;
            }
            var amountCell = ws.Cells[row, 4];
            amountCell.Value = node.Amount;
            amountCell.Style.Numberformat.Format = "#,##0.00";
            amountCell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
            row++;

            if (node.Kind == "leaf-table")
            {
                foreach (var r in node.Rows)
                {
                    var rowCell = ws.Cells[row, 1];
                    rowCell.Value = "- " + r.Label;
                    rowCell.Style.Indent = node.Depth + 1;
                    ws.Cells[row, 2].Value = r.Qualification;
                    ws.Cells[row, 3].Value = r.Qty;
                    var rowAmountCell = ws.Cells[row, 4];
                    rowAmountCell.Value = r.Amount;
                    rowAmountCell.Style.Numberformat.Format = "#,##0.00";
                    rowAmountCell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
                    row++;
                }
            }

            foreach (var child in node.Children)
            {
                WriteNode(child, ws, ref row);
            }
        }
    }
}
```

- [ ] **Step 2: Use it from the controller**

In `IncomeBudgetReportController.cs`, replace the `ExportXlsx` action and delete the old private `WriteNode` method entirely:

```csharp
        [Authorize]
        [HttpGet("{uid:guid}/export/xlsx")]
        public async Task<ActionResult> ExportXlsx([FromRoute] Guid uid)
        {
            var report = await _service.GetEntity(uid);
            if (report == null) return NotFound();
            var tree = _service.BuildTree(report);
            var bytes = await _service.BuildXlsx(report, tree);
            var fileName = $"income_budget_report_{uid}.xlsx";
            return File(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", fileName);
        }
```

- [ ] **Step 3: Add the wrapper method the controller now calls**

In `IncomeBudgetReportService.cs`, add (after `BuildTree`/`BuildNode`, this resolves the display strings the exporter needs):

```csharp
        public async Task<byte[]> BuildXlsx(v_income_budget_report report, ReportTreeNode tree)
        {
            var budgetYear = report.budget_year_uid != null
                ? await _context.v_budget_year.FirstOrDefaultAsync(y => y.budget_year_uid == report.budget_year_uid)
                : null;
            var personnel = report.personnel_statement_uid != null
                ? await _context.v_personnel_statement.FirstOrDefaultAsync(p => p.personnel_statement_uid == report.personnel_statement_uid)
                : null;
            var displayName = personnel?.display_name ?? personnel?.agency_name_th ?? report.sector_name_th ?? "";
            return IncomeBudgetReportXlsxExporter.Build(report, tree, budgetYear?.budget_year_name_th ?? "", displayName);
        }
```
If `v_budget_year`/`v_personnel_statement` aren't the exact `DbSet` property names on `Db`, grep for the actual names (`grep -rn "DbSet<v_budget_year>\|DbSet<v_personnel_statement>"`) and use those.

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`.

- [ ] **Step 5: Verify by downloading and opening the file**

```bash
curl -s "http://localhost:<port>/api/setting/income_budget_report/<uid>/export/xlsx" \
  -H "Authorization: Bearer <token>" -o /tmp/export-test.xlsx
```
Open `/tmp/export-test.xlsx` and confirm: title block at top, indented tree rows (not space-prefixed text — actual cell indent), bordered table, currency right-aligned with thousands separators, signature block at the bottom.

- [ ] **Step 6: Flag for human review**

In the task completion report, state explicitly: *"This export is a structural approximation built from the tree schema, not a reproduction of the real FastReport-generated government form (no template file was obtainable — see remediation plan Task 6 rationale). Before this is used for an actual government submission, compare it side-by-side against a real production `.xlsx` (e.g. once `rmutr.71dev.com/budget-api/...` is back up) and confirm with the human whether further layout changes are needed."*

- [ ] **Step 7: Commit**

```bash
git add Modules/IncomeBudgetReport/Services/IncomeBudgetReportXlsxExporter.cs Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs
git commit -m "feat: replace flat xlsx export with a structured, form-styled workbook"
```

---

### Task 7: Dual-write — mirror type-1 drafts into `revenue_draft_committee`

**Files:**
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs`
- Modify: `rmutr-api/.claude/worktrees/income-budget-report-api/Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs`

**Why:** Per the human's explicit "เปิดใช้เต็มรูปแบบเลย ทำ dual-write/union ข้อมูล" decision: type-2's picker (`income-budget-report.component.ts:132`, `RevenueDraftCommitteeSV.queryWithAgency('?type_id=1')`) and `change()` (reads `res.revenue_draft_committee_file`) still only read from the old `revenue_draft_committee` table. Rather than rewire type-2 (out of scope — it's still the untouched SyncFusion flow), `CreateDraft` and `UpdateLineAmounts` mirror a `revenue_draft_committee` row for every type-1 report, keeping its `revenue_draft_committee_file` populated with a freshly generated xlsx (via Task 6's exporter) using the exact same on-disk storage convention `DocumentUploadController` already uses (`Modules/Utilities/Controller/Upload.cs:23-60`) — writing directly to `application_setting.document_path` server-side, no client round-trip needed.

**Interfaces:**
- Consumes: `IncomeBudgetReportXlsxExporter.Build` (Task 6), `application_setting` (`Modules/Utilities/Models/application_setting.cs`, injected via `IOptions<application_setting>`), `t_revenue_draft_committee` (existing `DbSet` on `Db`, confirmed at `Modules/Setting/Databases/Db.cs:71`).
- Produces: `income_budget_report.revenue_draft_committee_uid` is now always populated for type-1 reports after `CreateDraft`.

- [ ] **Step 1: Inject `IOptions<application_setting>` into the service**

In `IncomeBudgetReportService.cs`, update the constructor. This mirrors `DocumentUploadController`'s exact pattern (`Modules/Utilities/Controller/Upload.cs:16-21`), which injects `IOptions<application_setting>` and stores `.Value`:

```csharp
        private readonly Db _context;
        private readonly rmutp_mooc_api.Modules.Utilities.Models.application_setting _appSetting;

        public IncomeBudgetReportService(Db context, Microsoft.Extensions.Options.IOptions<rmutp_mooc_api.Modules.Utilities.Models.application_setting> appSetting) : base(context)
        {
            _context = context;
            _appSetting = appSetting.Value;
        }
```

- [ ] **Step 2: Add the mirror-sync method**

In `IncomeBudgetReportService.cs`, add (after `BuildXlsx`):

```csharp
        private async Task SyncRevenueDraftCommitteeMirror(Guid reportUid, ClaimsIdentity identity)
        {
            var report = await GetEntity(reportUid);
            if (report == null || report.type_id != 1) return;

            var tree = BuildTree(report);
            var bytes = await BuildXlsx(report, tree);

            if (!Directory.Exists(_appSetting.document_path))
            {
                Directory.CreateDirectory(_appSetting.document_path);
            }
            var fileName = Guid.NewGuid() + ".xlsx";
            await System.IO.File.WriteAllBytesAsync(Path.Combine(_appSetting.document_path, fileName), bytes);
            var fileUrl = _appSetting.document_url + fileName;

            var personnel = report.personnel_statement_uid != null
                ? await _context.v_personnel_statement.FirstOrDefaultAsync(p => p.personnel_statement_uid == report.personnel_statement_uid)
                : null;
            var displayName = personnel?.display_name ?? personnel?.agency_name_th ?? report.sector_name_th ?? "";

            var mirror = report.revenue_draft_committee_uid != null
                ? await _context.t_revenue_draft_committee.FindAsync(report.revenue_draft_committee_uid)
                : null;

            if (mirror == null)
            {
                mirror = new t_revenue_draft_committee
                {
                    revenue_draft_committee_uid = Guid.NewGuid(),
                    type_id = 1,
                    personnel_statement_uid = report.personnel_statement_uid,
                    budget_year_uid = report.budget_year_uid,
                    status_id = 1,
                    owner_agency_uid = report.owner_agency_uid,
                };
                await _context.t_revenue_draft_committee.AddAsync(mirror);
                var trackedReport = await _context.t_income_budget_report.FindAsync(reportUid);
                trackedReport.revenue_draft_committee_uid = mirror.revenue_draft_committee_uid;
            }

            mirror.revenue_draft_committee_name_th = displayName;
            mirror.revenue_draft_committee_file = fileUrl;

            await _context.SaveChangesAsync(identity);
        }
```

Add `using System.IO;` to the top of the file if not already present.

- [ ] **Step 3: Call it from `CreateDraft` and after line updates**

In `CreateDraft`, change the final two lines from:
```csharp
            return await GetEntity(reportUid);
```
to:
```csharp
            await SyncRevenueDraftCommitteeMirror(reportUid, identity);
            return await GetEntity(reportUid);
```

In `UpdateLineAmounts` (Task 5), change the end of the method — replace:
```csharp
            await _context.SaveChangesAsync(identity);
            return rejected;
```
with:
```csharp
            await _context.SaveChangesAsync(identity);

            var reportUids = updates.Select(u => u.LineUid).Distinct().ToList();
            var affectedReportUids = await _context.t_income_budget_report_line
                .Where(l => reportUids.Contains(l.income_budget_report_line_uid.Value))
                .Select(l => l.income_budget_report_uid.Value)
                .Distinct()
                .ToListAsync();
            foreach (var reportUid in affectedReportUids)
            {
                await SyncRevenueDraftCommitteeMirror(reportUid, identity);
            }

            return rejected;
```

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-api/.claude/worktrees/income-budget-report-api
dotnet build
```
Expected: `Build succeeded. 0 Error(s)`. Fix any namespace mismatches against what `Upload.cs` actually uses (the exact `application_setting` namespace/using was copied from the earlier read of that file — verify it still matches).

- [ ] **Step 5: Verify end to end**

1. `POST create_draft` for a type-1 personnel_statement → confirm the response's `revenue_draft_committee_uid` is non-null.
2. `GET /api/setting/revenue_draft_committee/<that uid>` (or however the existing controller exposes single-record GET) → confirm `revenue_draft_committee_file` is a real, non-null URL and `type_id == 1`.
3. Download that URL and confirm it opens as a valid `.xlsx` (same file Task 6 verified).
4. `PUT lines` an amount change on that report → repeat step 2 and confirm `revenue_draft_committee_file` changed to a **new** URL (proving the mirror actually regenerates, not just points at a stale file).
5. `GET /api/setting/revenue_draft_committee/agency?type_id=1` (the exact call type-2's picker makes) → confirm the new draft appears in the list.

- [ ] **Step 6: Commit**

```bash
git add Modules/IncomeBudgetReport/Services/IncomeBudgetReportService.cs Modules/IncomeBudgetReport/Controllers/IncomeBudgetReportController.cs
git commit -m "feat: dual-write type-1 drafts into revenue_draft_committee so type-2's picker keeps working"
```

---

### Task 8: Frontend — union legacy `revenue_draft_committee` rows into the type-1 list

**Files:**
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/feature/income/draft/income-budget-report1/income-budget-report1-list/income-budget-report-list.component.ts`

**Why:** After Task 7, every *new* type-1 draft is mirrored into `revenue_draft_committee`, so it would actually show up fine if the list just queried `revenue_draft_committee` directly (like it did before the original Group A plan). But **historical rows that predate this whole feature** only exist in `revenue_draft_committee` and have no matching `income_budget_report` row — those must still be reachable (view/export via the old download, since they have no tree/lines to edit natively), and must not be shown twice once a legacy row eventually gets superseded. Union both sources, dedupe by the link column from Task 2, and flag legacy-only rows so Task 9 can route their edit action correctly.

**Interfaces:**
- Consumes: `income_budget_report.revenue_draft_committee_uid` (Task 2), the already-dual-written mirror rows (Task 7).
- Produces: each row in `summaryData` now carries `isLegacy: boolean`, consumed by Task 9's `onEdit`/`ondelete`.

- [ ] **Step 1: Extend `mapType1Rows` to also carry the link field, and add a legacy-union helper**

Replace the existing `mapType1Rows` method with:

```typescript
  /** type_id 1 drafts live in the new income_budget_report table (v_income_budget_report shape),
   *  but this list's template renders revenue_draft_committee_* fields. Alias the display fields
   *  onto the row so the existing template works unmodified, without stripping the real fields. */
  private mapType1Rows(rows: any[], personnelList: any[], budgetYearList: any[]): any[] {
    return (rows || []).map((row: any) => {
      const personnel = (personnelList || []).find(
        (p: any) => p.personnel_statement_uid == row.personnel_statement_uid
      )
      const budgetYear = (budgetYearList || []).find(
        (b: any) => b.budget_year_uid == row.budget_year_uid
      )
      const displayName = personnel?.display_name || personnel?.agency_name_th || ''
      return {
        ...row,
        revenue_draft_committee_uid: row.income_budget_report_uid,
        revenue_draft_committee_name_th: displayName,
        budget_year_name_th: budgetYear?.budget_year_name_th,
        isLegacy: false,
      }
    })
  }

  /** Historical type-1 rows that predate the native report table — they only exist in
   *  revenue_draft_committee and have no income_budget_report counterpart. Included so
   *  they stay reachable; excluded once a native row's dual-write has mirrored them
   *  (matched via income_budget_report.revenue_draft_committee_uid, aliased to
   *  revenue_draft_committee_uid on the mapped native rows above). */
  private unionLegacyRows(nativeRows: any[], legacyRows: any[]): any[] {
    const mirroredUids = new Set((nativeRows || []).map((r: any) => r.revenue_draft_committee_uid).filter(Boolean))
    const legacyOnly = (legacyRows || [])
      .filter((r: any) => !mirroredUids.has(r.revenue_draft_committee_uid))
      .map((r: any) => ({ ...r, isLegacy: true }))
    return [...nativeRows, ...legacyOnly]
  }
```

- [ ] **Step 2: Fetch both sources and union them in `ngOnInit`**

Replace the `concatMap` branch for `x.type == 1`:

```typescript
      concatMap(x=>{
        if (x.type == 1) {
          return combineLatest([
            this.IncomeBudgetReportSV.queryWithAgency('?type_id=1'),
            this.RevenueDraftCommitteeSV.queryWithAgency('?type_id=1'),
            this.personnelStatement$,
            this.budgetYear$,
          ]).pipe(
            map(([nativeRows, legacyRows, personnelList, budgetYearList]: [any[], any[], any[], any[]]) =>
              this.unionLegacyRows(this.mapType1Rows(nativeRows, personnelList, budgetYearList), legacyRows)
            )
          )
        }
        return this.RevenueDraftCommitteeSV.queryWithAgency(`?type_id=${x.type}`)
      }),
```

- [ ] **Step 3: Same union in `search()`**

Replace the `typeUrl == 1` branch of `source$`:

```typescript
    const source$ = this.typeUrl == 1
      ? combineLatest([
          this.IncomeBudgetReportSV.queryWithAgency(`?${queryStr}`),
          this.RevenueDraftCommitteeSV.queryWithAgency(`?${queryStr}`),
          this.personnelStatement$,
          this.budgetYear$,
        ]).pipe(
          map(([nativeRows, legacyRows, personnelList, budgetYearList]: [any[], any[], any[], any[]]) =>
            this.unionLegacyRows(this.mapType1Rows(nativeRows, personnelList, budgetYearList), legacyRows)
          )
        )
      : this.RevenueDraftCommitteeSV.queryWithAgency(`?${queryStr}`)
```

- [ ] **Step 4: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-web/.claude/worktrees/income-budget-report-api
npx tsc --noEmit
ng build --configuration production
```
Expected: zero new errors (ignore the pre-existing unrelated `form8.1.component.spec.ts` errors already noted in the Group A ledger).

- [ ] **Step 5: Verify in the browser**

Load `/app/income-budget-report-income1`. Confirm: rows created before this remediation (legacy, `revenue_draft_committee`-only) still appear; a freshly created draft (via `create_draft`, now dual-written) appears exactly once, not twice.

- [ ] **Step 6: Commit**

```bash
git add src/app/feature/income/draft/income-budget-report1/income-budget-report1-list/income-budget-report-list.component.ts
git commit -m "feat: union legacy revenue_draft_committee rows into the type-1 list, deduped against dual-written drafts"
```

---

### Task 9: Frontend — legacy-row edit routing, error/loading handling, decimal-input and indentation fixes

**Files:**
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/feature/income/draft/income-budget-report1/income-budget-report1-list/income-budget-report-list.component.ts`
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/feature/income/draft/income-budget-report1/income-budget-report1/income-budget-report.component.ts`
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/shared/components/budget-report-tree/budget-report-tree-node.component.ts`
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/shared/components/budget-report-tree/budget-report-tree-node.component.html`
- Modify: `rmutr-web/.claude/worktrees/income-budget-report-api/src/app/shared/components/budget-report-tree/budget-report-tree-node.component.scss`

**Why:** Four Important findings from the final review, all in scope for this remediation: (1) legacy rows (Task 8) have no `income_budget_report_uid` to edit natively — routing them into the tree UI would 404; (2) the whole native tree flow has zero error/loading handling, so any backend failure looks like nothing happened; (3) `pendingChanges`/`tree` aren't cleared when a user switches which personnel_statement they're viewing, so edits can leak across selections; (4) the amount `<input type="number">` bound via `[value]`+`(input)` loses a user's in-progress decimal typing (e.g. typing `"50."` resets to `0`), and the tree's CSS indentation compounds quadratically by depth.

**Interfaces:**
- Consumes: `row.isLegacy` (Task 8).
- Produces: none consumed by later tasks (this is the last frontend task before verification).

- [ ] **Step 1: Route legacy rows to the old edit flow via a query param**

In `income-budget-report-list.component.ts`, replace `onEdit`:

```typescript
  onEdit(row: any){
    const uid = row.revenue_draft_committee_uid
    const legacyQuery = row.isLegacy ? { queryParams: { legacy: '1' } } : {}
    if(this.typeUrl == 1){
      this.router.navigate(['/app/income-budget-report-income1/edit', uid], legacyQuery)
    }
    else if(this.typeUrl == 2){
      this.router.navigate(['/app/income-budget-report-income2/edit',uid])
    }
    else if(this.typeUrl == 3){
      this.router.navigate(['/app/income-budget-report-income3/edit',uid])
    }
    else if(this.typeUrl == 4){
      this.router.navigate(['/app/allocate-income-budget/edit',uid])
    }
    else if(this.typeUrl == 5){
      this.router.navigate(['/app/income-expense-estimates/edit',uid])
    }
    else if(this.typeUrl == 6){
      this.router.navigate(['/app/income-expense-estimates-02/edit',uid])
    }
    else if(this.typeUrl == 10){
      this.router.navigate(['/app/educational-materials/edit',uid])
    }
  }
```
(signature changed from `onEdit(uid)` to `onEdit(row: any)` — update the template call site.)

In `income-budget-report-list.component.html`, change the edit icon's click handler from `(click)="onEdit(x.revenue_draft_committee_uid)"` to `(click)="onEdit(x)"`.

Also update `ondelete` to branch on legacy the same way — replace its body:
```typescript
  ondelete(value){
    console.log(value)
    this.swSV.confirm().pipe(
      filter(x => x.isConfirmed),
      concatMap(x => {
        const delete$ = (this.typeUrl == 1 && !value.isLegacy)
          ? this.IncomeBudgetReportSV.deleteData(value.revenue_draft_committee_uid)
          : this.RevenueDraftCommitteeSV.deleteData(value.revenue_draft_committee_uid)
        return delete$.pipe(
          tap(x => this.swSV.removeSuccess()),
          tap(x => this.ngOnInit()),
          tap(x => this.cdRef.detectChanges())
        )
      })
    ).subscribe()
   }
```
and in the template, change `(click)="ondelete(x.revenue_draft_committee_uid)"` to `(click)="ondelete(x)"`.

- [ ] **Step 2: Make the edit-mode branch respect the legacy flag**

In `income-budget-report.component.ts`, `ngOnInit`'s `case 'edit':` block, replace:
```typescript
        if (this.typeId == 1) {
          this.reportUid = this.uniquekey;
          this.loadTree();
        } else {
```
with:
```typescript
        const isLegacyEdit = this.activatedRoute.snapshot.queryParams?.legacy === '1';
        if (this.typeId == 1 && !isLegacyEdit) {
          this.reportUid = this.uniquekey;
          this.loadTree();
        } else {
```
Add a field near the other type-1 state fields:
```typescript
  /** true when editing a legacy revenue_draft_committee-only row (no income_budget_report
   *  counterpart) via the ?legacy=1 route — falls back to the old SyncFusion edit UI even
   *  though typeId === 1. */
  isLegacyEdit = false
```
and set it alongside the check above:
```typescript
        this.isLegacyEdit = this.activatedRoute.snapshot.queryParams?.legacy === '1';
        if (this.typeId == 1 && !this.isLegacyEdit) {
```
(remove the local `const isLegacyEdit` and use `this.isLegacyEdit` in the `if` instead, to also expose it to the template.)

In `income-budget-report.component.html`, change the top-level template gate from `*ngIf="typeId === 1; else oldReportUi"` to `*ngIf="typeId === 1 && !isLegacyEdit; else oldReportUi"`. This is the only change to that template's structure — everything inside `#oldReportUi` stays byte-identical, per the Global Constraint.

- [ ] **Step 3: Add error/loading handling to the four native-flow service calls**

In `income-budget-report.component.ts`, replace `onPersonnelStatementChange`:
```typescript
  onPersonnelStatementChange(personnelStatementUid: string): void {
    if (!personnelStatementUid) return;
    if (this.state === 'edit') return;
    this.pendingChanges.clear();
    this.tree = null;
    this.loading();
    this.incomeBudgetReportSV.createDraft(personnelStatementUid).pipe(
      tap((report: any) => {
        this.reportUid = report.income_budget_report_uid;
        this.loadTree();
      }),
      catchError(err => {
        this.closeLoading();
        Swal.fire(err.error?.description || 'เกิดข้อผิดพลาด', '', 'error');
        return throwError(err);
      }),
    ).subscribe();
  }
```

Replace `loadTree`:
```typescript
  loadTree(): void {
    if (!this.reportUid) return;
    this.incomeBudgetReportSV.getTree(this.reportUid).pipe(
      tap((tree) => { this.tree = tree; this.closeLoading(); this.cdRef.detectChanges(); }),
      catchError(err => {
        this.closeLoading();
        Swal.fire(err.error?.description || 'ไม่พบข้อมูลรายงาน', '', 'error');
        return throwError(err);
      }),
    ).subscribe();
  }
```

Replace `saveTree`:
```typescript
  /** Saves the edited line amounts of the native tree report.
   *  Named apart from save() above, which saves the SyncFusion workbook for types 2..10. */
  saveTree(): void {
    if (!this.reportUid || this.pendingChanges.size === 0) return;
    const lines = Array.from(this.pendingChanges.entries()).map(([lineUid, amount]) => ({
      income_budget_report_line_uid: lineUid,
      amount,
    }));
    this.loading();
    this.incomeBudgetReportSV.updateLineAmounts(lines).pipe(
      tap(() => {
        this.pendingChanges.clear();
        this.closeLoading();
        this.AppSV.swaltAlert('บันทึกสำเร็จ');
        this.loadTree();
      }),
      catchError(err => {
        this.closeLoading();
        Swal.fire(err.error?.description || 'บันทึกไม่สำเร็จ', '', 'error');
        return throwError(err);
      }),
    ).subscribe();
  }
```

Replace `exportXlsx`:
```typescript
  exportXlsx(): void {
    if (!this.reportUid) return;
    const url = this.incomeBudgetReportSV.exportXlsxUrl(this.reportUid);
    this.loading();
    this.incomeBudgetReportSV.getExcelReport(url).pipe(
      tap((fileUrl: any) => { this.closeLoading(); window.open(fileUrl); }),
      catchError(err => {
        this.closeLoading();
        Swal.fire(err.error?.description || 'ส่งออกไม่สำเร็จ', '', 'error');
        return throwError(err);
      }),
    ).subscribe();
  }
```

`catchError`, `throwError`, and `Swal` are already imported in this file (confirmed: `catchError` is in the existing `rxjs/operators` import, `throwError` in the `rxjs` import, `Swal` via `import Swal from 'sweetalert2';`).

- [ ] **Step 4: Fix the decimal-input round-trip bug**

In `budget-report-tree-node.component.html`, change both amount inputs from `(input)` to `(change)` (matches user intent — commit on blur/enter, not on every keystroke, so a partial `"50."` isn't clobbered mid-type):

```html
      <input
        *ngIf="!node.locked; else lockedAmount"
        type="number"
        class="amount-input"
        [value]="node.amount"
        (change)="onLeafAmountInput($any($event.target).value)"
      />
```
and
```html
          <input
            *ngIf="!row.locked; else lockedRowAmount"
            type="number"
            class="amount-input"
            [value]="row.amount"
            (change)="onRowAmountInput(row, $any($event.target).value)"
          />
```
(`onLeafAmountInput`/`onRowAmountInput` in the `.ts` file don't need to change — they already parse the string value correctly; the bug was purely the `(input)` event firing on every keystroke against a `[value]` binding that immediately re-renders the parsed number.)

- [ ] **Step 5: Fix the quadratic indentation**

In `budget-report-tree-node.component.scss`, find the rule using `--depth` for `padding-left` (it's applied per-nesting-level, so nested `.tree-node`s compound it). Replace it so indentation is a flat per-level amount applied only once per node, not inherited from ancestors. Read the current file first to get the exact existing selector, then change the padding calculation from `calc(var(--depth,0) * 20px)` to a fixed `20px` applied unconditionally to `.tree-node .tree-node` (i.e. indent by one level relative to its immediate parent, not by absolute depth):

```scss
.tree-node {
  .tree-node {
    padding-left: 20px;
  }
}
```
Remove the `[style.--depth]` binding usage for padding purposes if the `.scss` no longer references `--depth` anywhere after this change — check `budget-report-tree-node.component.html:1`'s `[style.--depth]="node.depth"` binding and leave it in place only if something else in the `.scss` still uses it (e.g. for a `lvl-N` class-based rule); otherwise it's harmless to leave unused.

- [ ] **Step 6: Build**

```bash
cd /Users/nut.looknut/Project/rmutr/rmutr-web/.claude/worktrees/income-budget-report-api
npx tsc --noEmit
ng build --configuration production
```
Expected: zero new errors.

- [ ] **Step 7: Verify in the browser**

1. Create a type-1 draft, disconnect network (devtools offline mode), try saving an amount — confirm an error `Swal` appears instead of silence.
2. Reconnect, edit an amount partially (type `"1234."` and pause) — confirm the field doesn't reset to `0` mid-type.
3. Pick personnel A, edit an amount, then pick personnel B without saving — confirm B's tree loads clean with no leftover pending change from A.
4. Visually inspect indentation at the deepest tree level (`out{N}-invest-equip`, depth 5) — confirm it's not visually indented ~300px, just proportionally nested.
5. Click edit on a legacy-flagged row from the list (Task 8) — confirm it opens the old SyncFusion UI (not a blank tree page).

- [ ] **Step 8: Commit**

```bash
git add src/app/feature/income/draft/income-budget-report1/income-budget-report1-list/income-budget-report-list.component.ts src/app/feature/income/draft/income-budget-report1/income-budget-report1/income-budget-report.component.ts src/app/feature/income/draft/income-budget-report1/income-budget-report1/income-budget-report.component.html src/app/shared/components/budget-report-tree/budget-report-tree-node.component.html src/app/shared/components/budget-report-tree/budget-report-tree-node.component.scss
git commit -m "fix: legacy-row edit routing, error/loading handling, decimal input, and indentation"
```

---

### Task 10: End-to-end verification against real data (both repos)

**Files:** none (verification only — this is the equivalent of the original Group A plan's Task 13, which was never executed; that gap is why every defect this remediation plan fixes survived 12 clean task-level reviews)

- [ ] **Step 1: Full round trip with real production-shaped data**

Using a real (or realistic test) `personnel_statement_uid` with known ร.2 detail rows and, ideally, a `budget_year_uid` that also has ร.4/ร.5 rows:
1. Navigate to `/app/income-budget-report-income1/add`, pick the personnel_statement.
2. Confirm the tree renders with personnel rows (locked) **and** the ค่าตอบแทน/เงินเพิ่มค่าครองชีพ/งบรายจ่ายอื่นๆ fields editable (not showing `0` permanently) **and**, if the test data has ร.4/ร.5 rows, the ค่าครุภัณฑ์/ค่าที่ดินฯ tables populated.
3. Edit an unlocked amount (e.g. ค่าตอบแทน ค่าใช้สอยและค่าวัสดุ). Confirm the parent group totals update live in the browser.
4. Click บันทึก. Confirm a success message appears.
5. **Reload the page** (full browser refresh, not SPA navigation) and re-open the same report via the list's edit action. Confirm the edited amount survived — this is the check that would have caught the original silent-save-loss bug.
6. Click ส่งออก Excel. Confirm the file downloads (not a 401) and opens with the structured layout from Task 6.
7. Go to `/app/income-budget-report-income2/add`, open the picker. Confirm the type-1 report just created/edited appears in the list (proves the Task 7 dual-write worked end to end, not just in isolated `curl` checks).
8. Go back to `/app/income-budget-report-income1`, confirm the report appears exactly once (not duplicated against any legacy row).
9. If a genuine legacy row exists in this environment (predating this feature), click its edit action and confirm it opens the old SyncFusion UI correctly, and that types 2-10's own add/edit flows are visually and functionally unchanged from before this whole feature branch existed.

- [ ] **Step 2: Record the result in the ledger**

Append to `/Users/nut.looknut/Project/rmutr/.superpowers/sdd/2026-08-05-income-budget-report-native-group-a/progress.md`:
```
=== Remediation plan (2026-08-05-income-budget-report-native-group-a-remediation.md) Tasks 1-10 complete. ===
Task 10 (end-to-end verification): [PASS/FAIL per step above — fill in actual results, do not mark complete without having actually run every step against a real environment]
```

- [ ] **Step 3: Request final whole-branch re-review**

Once Task 10 passes for real, dispatch the same final whole-branch review process used for the original Group A plan (`superpowers:requesting-code-review`'s template, on the most capable model, `scripts/review-package` diffed from each worktree's original Group A merge-base through the new remediation HEAD) before merge — do not skip this because the individual remediation tasks were reviewed; the whole point of Group A's own final review was that whole-branch issues aren't visible task-by-task, and this remediation branch is now big enough to have the same risk.