feat(机器人任务): 实现换盘任务假电芯补充逻辑

wanshenmean

7 小时以前 ad64840cc04dac2278ca02f22ddc02b1a218e9cf

feat(机器人任务): 实现换盘任务假电芯补充逻辑

feat(机器人任务): 实现换盘任务假电芯补充逻辑

添加假电芯平面点位表实体 Dt_FakeBatteryPosition 及相关仓储服务层
RobotSocketState 添加 IsInFakeBatteryMode 标志
RobotTaskProcessor 添加假电芯取货指令方法
实现 HandlePutFinishedStateAsync 中的 ChangePallet 完整逻辑

fix(Robot): GetNextAvailable按行内连续性查找可用点位

fix(Robot): GetNextAvailable改为查找连续可用的N个点位

feat(Robot): 实现换盘任务假电芯补充逻辑

feat(Robot): RobotTaskProcessor 添加假电芯取货指令方法

feat(Robot): RobotSocketState 添加 IsInFakeBatteryMode 标志

feat(Robot): 添加假电芯位置服务层

feat(Robot): 添加假电芯位置仓储层

feat(Robot): 添加假电芯平面点位表实体 Dt_FakeBatteryPosition

 Code/.omc/state/agent-replay-80f81c54-c5ed-4867-b777-d2d640ee3b40.jsonl

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1 @@
{"t":0,"agent":"system","event":"skill_invoked","skill_name":"superpowers:brainstorming"}

 Code/.omc/state/agent-replay-d836b656-7d6b-4a00-b9ed-f46b82f58345.jsonl

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,21 @@
{"t":0,"agent":"system","event":"skill_invoked","skill_name":"superpowers:writing-plans"}
{"t":0,"agent":"system","event":"skill_invoked","skill_name":"superpowers:subagent-driven-development"}
{"t":0,"agent":"a2061bd","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a2061bd","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":44758}
{"t":0,"agent":"a33f78a","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a33f78a","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":81574}
{"t":0,"agent":"a9c381b","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a9c381b","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":81306}
{"t":0,"agent":"a614ea5","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a614ea5","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":72773}
{"t":0,"agent":"a3143b3","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a3143b3","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":90995}
{"t":0,"agent":"a177bc3","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a177bc3","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":88225}
{"t":0,"agent":"a550b7f","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a550b7f","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":41024}
{"t":0,"agent":"acd1aa5","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"acd1aa5","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":90649}
{"t":0,"agent":"a991ee2","agent_type":"general-purpose","event":"agent_start","parent_mode":"none"}
{"t":0,"agent":"a991ee2","agent_type":"general-purpose","event":"agent_stop","success":true,"duration_ms":246360}
{"t":0,"agent":"system","event":"skill_invoked","skill_name":"superpowers:finishing-a-development-branch"}

 Code/.omc/state/idle-notif-cooldown.json

@@ -1,3 +1,3 @@
{
  "lastSentAt": "2026-04-15T11:40:34.475Z"
  "lastSentAt": "2026-04-15T14:42:46.838Z"
}

 Code/.omc/state/last-tool-error.json

@@ -1,7 +1,7 @@
{
  "tool_name": "Bash",
  "tool_input_preview": "{\"command\":\"ls \\\"D:\\\\Git\\\\ShanMeiXinNengYuan\\\\Code\\\\WMS\\\\WIDESEA_WMSClient\\\\src\\\\api\\\\\\\" 2>/dev/null | head -20\",\"description\":\"Check api directory structure\"}",
  "error": "Exit code 2\n/usr/bin/bash: eval: line 1: unexpected EOF while looking for matching `\"'",
  "timestamp": "2026-04-13T03:27:59.200Z",
  "retry_count": 6
  "tool_input_preview": "{\"command\":\"dotnet build D:/Git/ShanMeiXinNengYuan/Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server.sln\",\"timeout\":300000,\"description\":\"Build WCS solution to verify fix\"}",
  "error": "Exit code 1\n  æ­£åœ¨ç¡®å®šè¦è¿˜åŽŸçš„项目…\r\n  æ‰€æœ‰é¡¹ç›®å‡æ˜¯æœ€æ–°çš„，无法还原。\r\n  WIDESEAWCS_Common -> D:\\Git\\ShanMeiXinNengYuan\\Code\\WCS\\WIDESEAWCS_Server\\WIDESEAWCS_Common\\bin\\Debug\\net8.0\\WIDESEAWCS_Common.dll\r\nD:\\Git\\ShanMeiXinNengYuan\\Code\\WCS\\WIDESEAWCS_Server\\WIDESEAWCS_Communicator\\AllenBrandly\\AllenBrandlyEtherNetCommunicator.cs(110,80): warning CS1570: XML æ³¨é‡Šå‡ºçŽ° XML æ ¼å¼é”™è¯¯ --“结束标记“param”与开始标记“T”不匹配。” [D:\\Git\\ShanMeiXinNengYuan\\Code\\WCS\\WIDESEAWCS_Server\\WIDESEAWCS_Communicator\\WIDESEAWCS_Communicator.csproj]\r\nD:\\Git\\ShanM...",
  "timestamp": "2026-04-15T14:12:47.386Z",
  "retry_count": 1
}

 Code/.omc/state/mission-state.json

@@ -1,5 +1,5 @@
{
  "updatedAt": "2026-04-15T06:10:46.493Z",
  "updatedAt": "2026-04-15T14:16:41.286Z",
  "missions": [
    {
      "id": "session:9007b9ea-1eb6-4d24-8fe7-2c3a949eac88:none",
@@ -476,6 +476,150 @@
          "sourceKey": "session-stop:a48e41df38204e6dc"
        }
      ]
    },
    {
      "id": "session:d836b656-7d6b-4a00-b9ed-f46b82f58345:none",
      "source": "session",
      "name": "none",
      "objective": "Session mission",
      "createdAt": "2026-04-15T14:00:27.304Z",
      "updatedAt": "2026-04-15T14:16:41.286Z",
      "status": "done",
      "workerCount": 9,
      "taskCounts": {
        "total": 9,
        "pending": 0,
        "blocked": 0,
        "inProgress": 0,
        "completed": 9,
        "failed": 0
      },
      "agents": [
        {
          "name": "general-purpose:a2061bd",
          "role": "general-purpose",
          "ownership": "a2061bd1c8b6f066e",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:01:12.062Z"
        },
        {
          "name": "general-purpose:a33f78a",
          "role": "general-purpose",
          "ownership": "a33f78a441c700f07",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:03:00.165Z"
        },
        {
          "name": "general-purpose:a9c381b",
          "role": "general-purpose",
          "ownership": "a9c381b5f67087dae",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:04:44.132Z"
        },
        {
          "name": "general-purpose:a614ea5",
          "role": "general-purpose",
          "ownership": "a614ea573436c827d",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:06:11.349Z"
        },
        {
          "name": "general-purpose:a3143b3",
          "role": "general-purpose",
          "ownership": "a3143b3511395abdc",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:08:04.129Z"
        },
        {
          "name": "general-purpose:a177bc3",
          "role": "general-purpose",
          "ownership": "a177bc320ae6cc4dc",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:09:53.582Z"
        },
        {
          "name": "general-purpose:a550b7f",
          "role": "general-purpose",
          "ownership": "a550b7f6cb598b4c0",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:10:46.231Z"
        },
        {
          "name": "general-purpose:acd1aa5",
          "role": "general-purpose",
          "ownership": "acd1aa52bf3dd06d4",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:12:28.373Z"
        },
        {
          "name": "general-purpose:a991ee2",
          "role": "general-purpose",
          "ownership": "a991ee262522932f5",
          "status": "done",
          "currentStep": null,
          "latestUpdate": "completed",
          "completedSummary": null,
          "updatedAt": "2026-04-15T14:16:41.286Z"
        }
      ],
      "timeline": [
        {
          "id": "session-start:acd1aa52bf3dd06d4:2026-04-15T14:10:57.724Z",
          "at": "2026-04-15T14:10:57.724Z",
          "kind": "update",
          "agent": "general-purpose:acd1aa5",
          "detail": "started general-purpose:acd1aa5",
          "sourceKey": "session-start:acd1aa52bf3dd06d4"
        },
        {
          "id": "session-stop:acd1aa52bf3dd06d4:2026-04-15T14:12:28.373Z",
          "at": "2026-04-15T14:12:28.373Z",
          "kind": "completion",
          "agent": "general-purpose:acd1aa5",
          "detail": "completed",
          "sourceKey": "session-stop:acd1aa52bf3dd06d4"
        },
        {
          "id": "session-start:a991ee262522932f5:2026-04-15T14:12:34.926Z",
          "at": "2026-04-15T14:12:34.926Z",
          "kind": "update",
          "agent": "general-purpose:a991ee2",
          "detail": "started general-purpose:a991ee2",
          "sourceKey": "session-start:a991ee262522932f5"
        },
        {
          "id": "session-stop:a991ee262522932f5:2026-04-15T14:16:41.286Z",
          "at": "2026-04-15T14:16:41.286Z",
          "kind": "completion",
          "agent": "general-purpose:a991ee2",
          "detail": "completed",
          "sourceKey": "session-stop:a991ee262522932f5"
        }
      ]
    }
  ]
}

 Code/.omc/state/subagent-tracking.json

@@ -296,10 +296,91 @@
      "status": "completed",
      "completed_at": "2026-04-15T06:10:46.493Z",
      "duration_ms": 51400
    },
    {
      "agent_id": "a2061bd1c8b6f066e",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:00:27.304Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:01:12.062Z",
      "duration_ms": 44758
    },
    {
      "agent_id": "a33f78a441c700f07",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:01:38.591Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:03:00.165Z",
      "duration_ms": 81574
    },
    {
      "agent_id": "a9c381b5f67087dae",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:03:22.826Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:04:44.132Z",
      "duration_ms": 81306
    },
    {
      "agent_id": "a614ea573436c827d",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:04:58.576Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:06:11.349Z",
      "duration_ms": 72773
    },
    {
      "agent_id": "a3143b3511395abdc",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:06:33.134Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:08:04.129Z",
      "duration_ms": 90995
    },
    {
      "agent_id": "a177bc320ae6cc4dc",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:08:25.357Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:09:53.582Z",
      "duration_ms": 88225
    },
    {
      "agent_id": "a550b7f6cb598b4c0",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:10:05.207Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:10:46.231Z",
      "duration_ms": 41024
    },
    {
      "agent_id": "acd1aa52bf3dd06d4",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:10:57.724Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:12:28.373Z",
      "duration_ms": 90649
    },
    {
      "agent_id": "a991ee262522932f5",
      "agent_type": "general-purpose",
      "started_at": "2026-04-15T14:12:34.926Z",
      "parent_mode": "none",
      "status": "completed",
      "completed_at": "2026-04-15T14:16:41.286Z",
      "duration_ms": 246360
    }
  ],
  "total_spawned": 33,
  "total_completed": 33,
  "total_spawned": 42,
  "total_completed": 42,
  "total_failed": 0,
  "last_updated": "2026-04-15T06:10:46.596Z"
  "last_updated": "2026-04-15T14:16:41.394Z"
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_DTO/TaskInfo/WMSTaskDTO.cs

@@ -66,6 +66,11 @@
        public int Grade { get; set; }

        /// <summary>
        /// ä»»åŠ¡æ•°é‡
        /// </summary>
        public int TaskQuantity { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public int WarehouseId { get; set; }

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoRepository/IFakeBatteryPositionRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_ITaskInfoRepository
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®ä»“储接口
    /// </summary>
    public interface IFakeBatteryPositionRepository : IRepository<Dt_FakeBatteryPosition>
    {
        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表，按PositionIndex升序</returns>
        List<int> GetNextAvailable(int count);

        /// <summary>
        /// é‡ç½®æ‰€æœ‰ç‚¹ä½ä¸ºæœªä½¿ç”¨
        /// </summary>
        /// <returns>影响的行数</returns>
        int ResetAll();

        /// <summary>
        /// æ ‡è®°æŒ‡å®šç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// </summary>
        /// <param name="positions">点位索引列表</param>
        /// <returns>是否成功</returns>
        bool MarkAsUsed(List<int> positions);

        /// <summary>
        /// æ ¹æ®è¡Œå’Œåˆ—获取点位索引
        /// </summary>
        /// <param name="row">行（1-3）</param>
        /// <param name="col">列（1-16）</param>
        /// <returns>点位索引（1-48），找不到返回null</returns>
        int? GetPositionIndex(int row, int col);
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/IFakeBatteryPositionService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,49 @@
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_ITaskInfoService
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®æœåŠ¡æŽ¥å£
    /// </summary>
    public interface IFakeBatteryPositionService : IService<Dt_FakeBatteryPosition>
    {
        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表，按PositionIndex升序</returns>
        List<int> GetNextAvailable(int count);

        /// <summary>
        /// é‡ç½®æ‰€æœ‰ç‚¹ä½ä¸ºæœªä½¿ç”¨
        /// </summary>
        /// <returns>影响的行数</returns>
        int ResetAll();

        /// <summary>
        /// æ ‡è®°æŒ‡å®šç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// </summary>
        /// <param name="positions">点位索引列表</param>
        /// <returns>是否成功</returns>
        bool MarkAsUsed(List<int> positions);

        /// <summary>
        /// æ ¹æ®è¡Œå’Œåˆ—获取点位索引
        /// </summary>
        /// <param name="row">行（1-3）</param>
        /// <param name="col">列（1-16）</param>
        /// <returns>点位索引（1-48），找不到返回null</returns>
        int? GetPositionIndex(int row, int col);

        /// <summary>
        /// åˆå§‹åŒ–假电芯点位表（48个点位）
        /// </summary>
        /// <remarks>
        /// ä»…当表为空时插入1-48的初始数据。
        /// 3行×16列，行优先排列。
        /// </remarks>
        /// <returns>是否成功</returns>
        bool InitializeIfEmpty();
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/Dt_FakeBatteryPosition.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,50 @@
using SqlSugar;
using WIDESEAWCS_Core.DB.Models;

namespace WIDESEAWCS_Model.Models
{
    /// <summary>
    /// å‡ç”µèŠ¯å¹³é¢ç‚¹ä½è¡¨
    /// </summary>
    /// <remarks>
    /// ç”¨äºŽç®¡ç†å‡ç”µèŠ¯æŠ“取点的平面点位信息。
    /// 3行×16列布局，共48个点位（1-48），行优先排列。
    /// ç¬¬1行：1-16，第2行：17-32，第3行：33-48。
    /// </remarks>
    [SugarTable(nameof(Dt_FakeBatteryPosition), "假电芯平面点位表")]
    public class Dt_FakeBatteryPosition : BaseEntity
    {
        /// <summary>
        /// ä¸»é”®ID
        /// </summary>
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键ID")]
        public int Id { get; set; }

        /// <summary>
        /// å¹³é¢ç‚¹ä½ç´¢å¼•ï¼ˆ1-48）
        /// </summary>
        /// <remarks>
        /// 3×16布局，行优先（1-16为第1行，17-32为第2行，33-48为第3行）。
        /// </remarks>
        [SugarColumn(ColumnDescription = "平面点位索引")]
        public int PositionIndex { get; set; }

        /// <summary>
        /// æ‰€åœ¨è¡Œï¼ˆ1-3）
        /// </summary>
        [SugarColumn(ColumnDescription = "所在行")]
        public int Row { get; set; }

        /// <summary>
        /// æ‰€åœ¨åˆ—（1-16）
        /// </summary>
        [SugarColumn(ColumnDescription = "所在列")]
        public int Col { get; set; }

        /// <summary>
        /// æ˜¯å¦å·²ä½¿ç”¨
        /// </summary>
        [SugarColumn(ColumnDescription = "是否已使用")]
        public bool IsUsed { get; set; }
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoRepository/FakeBatteryPositionRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_TaskInfoRepository
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®ä»“储实现
    /// </summary>
    public class FakeBatteryPositionRepository : RepositoryBase<Dt_FakeBatteryPosition>, IFakeBatteryPositionRepository
    {
        public FakeBatteryPositionRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
        {
        }

        /// <inheritdoc/>
        public List<int> GetNextAvailable(int count)
        {
            // æŒ‰è¡Œå’Œåˆ—升序查询所有点位
            var allPositions = Db.Queryable<Dt_FakeBatteryPosition>()
                .OrderBy(x => x.Row)
                .OrderBy(x => x.Col)
                .ToList();

            // æŒ‰è¡Œåˆ†ç»„，在每行内查找连续可用的点位
            var rows = allPositions.GroupBy(p => p.Row).OrderBy(g => g.Key);

            foreach (var rowGroup in rows)
            {
                var rowPositions = rowGroup.OrderBy(p => p.Col).ToList();

                // åœ¨è¿™ä¸€è¡Œå†…查找连续的count个未使用点位
                for (int i = 0; i <= rowPositions.Count - count; i++)
                {
                    var candidate = rowPositions.Skip(i).Take(count).ToList();

                    // æ£€æŸ¥è¿™count个点位是否都是连续的列（Col连续）且未使用
                    bool allAvailable = candidate.All(p => !p.IsUsed);
                    bool allConsecutive = true;
                    for (int j = 1; j < candidate.Count; j++)
                    {
                        if (candidate[j].Col != candidate[j - 1].Col + 1)
                        {
                            allConsecutive = false;
                            break;
                        }
                    }

                    if (allAvailable && allConsecutive)
                    {
                        return candidate.Select(p => p.PositionIndex).ToList();
                    }
                }
            }

            // æ²¡æœ‰æ‰¾åˆ°è¿žç»­çš„空点位，返回空列表
            return new List<int>();
        }

        /// <inheritdoc/>
        public int ResetAll()
        {
            return Db.Updateable<Dt_FakeBatteryPosition>()
                .SetColumns(x => x.IsUsed, false)
                .ExecuteCommand();
        }

        /// <inheritdoc/>
        public bool MarkAsUsed(List<int> positions)
        {
            if (positions == null || positions.Count == 0)
                return true;

            return Db.Updateable<Dt_FakeBatteryPosition>()
                .SetColumns(x => x.IsUsed, true)
                .Where(x => positions.Contains(x.PositionIndex))
                .ExecuteCommand() > 0;
        }

        /// <inheritdoc/>
        public int? GetPositionIndex(int row, int col)
        {
            var entity = Db.Queryable<Dt_FakeBatteryPosition>()
                .Where(x => x.Row == row && x.Col == col)
                .Select(x => new { x.PositionIndex })
                .First();
            return entity?.PositionIndex;
        }
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/FakeBatteryPositionService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_TaskInfoService
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®æœåŠ¡å®žçŽ°
    /// </summary>
    public class FakeBatteryPositionService : ServiceBase<Dt_FakeBatteryPosition, IFakeBatteryPositionRepository>, IFakeBatteryPositionService
    {
        public FakeBatteryPositionService(IFakeBatteryPositionRepository BaseDal) : base(BaseDal)
        {
        }

        /// <inheritdoc/>
        public List<int> GetNextAvailable(int count)
        {
            return BaseDal.GetNextAvailable(count);
        }

        /// <inheritdoc/>
        public int ResetAll()
        {
            return BaseDal.ResetAll();
        }

        /// <inheritdoc/>
        public bool MarkAsUsed(List<int> positions)
        {
            return BaseDal.MarkAsUsed(positions);
        }

        /// <inheritdoc/>
        public int? GetPositionIndex(int row, int col)
        {
            return BaseDal.GetPositionIndex(row, col);
        }

        /// <inheritdoc/>
        public bool InitializeIfEmpty()
        {
            var existing = BaseDal.QueryFirst(x => true);
            if (existing != null)
                return true;

            // ç”Ÿæˆ48个点位：3行×16列，行优先
            var positions = new List<Dt_FakeBatteryPosition>();
            for (int row = 1; row <= 3; row++)
            {
                for (int col = 1; col <= 16; col++)
                {
                    int positionIndex = (row - 1) * 16 + col;
                    positions.Add(new Dt_FakeBatteryPosition
                    {
                        PositionIndex = positionIndex,
                        Row = row,
                        Col = col,
                        IsUsed = false,
                        Creater = "System"
                    });
                }
            }

            return BaseDal.AddData(positions) > 0;
        }
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/RobotTaskService.cs

@@ -90,7 +90,7 @@
                    RobotTaskState = taskDTO.TaskStatus,
                    RobotGrade = taskDTO.Grade,
                    Creater = "WMS",
                    RobotTaskTotalNum = 48,
                    RobotTaskTotalNum = taskDTO.TaskQuantity,
                };

                BaseDal.AddData(task);

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotJob.cs

@@ -104,7 +104,8 @@
            ITaskService taskService,
            ICacheService cache,
            HttpClientHelper httpClientHelper,
            ILogger<RobotJob> logger)
            ILogger<RobotJob> logger,
            IFakeBatteryPositionService fakeBatteryPositionService)
        {
            // åˆå§‹åŒ–状态管理器，传入缓存服务
            _stateManager = new RobotStateManager(cache, _logger);
@@ -115,7 +116,7 @@
            ISocketClientGateway socketGateway = new SocketClientGateway(tcpSocket);

            // åˆå§‹åŒ–任务处理器
            _taskProcessor = new RobotTaskProcessor(socketGateway, _stateManager, robotTaskService, taskService, httpClientHelper, _logger);
            _taskProcessor = new RobotTaskProcessor(socketGateway, _stateManager, robotTaskService, taskService, httpClientHelper, _logger, fakeBatteryPositionService);

            // åˆå§‹åŒ–客户端管理器
            _clientManager = new RobotClientManager(tcpSocket, _stateManager, _logger);

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotSocketState.cs

@@ -173,5 +173,13 @@
        /// å½“达到 MaxTaskTotalNum (48) æ—¶ï¼Œä¸å†ä¸‹å‘新任务。
        /// </remarks>
        public int RobotTaskTotalNum { get; set; }

        /// <summary>
        /// æ˜¯å¦å¤„于假电芯补充模式
        /// </summary>
        /// <remarks>
        /// å½“正常电芯任务完成后设为 true，机器人从假电芯位置补充电芯至48个。
        /// </remarks>
        public bool IsInFakeBatteryMode { get; set; }
    }
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs

@@ -69,6 +69,14 @@
        private readonly HttpClientHelper _httpClientHelper;

        /// <summary>
        /// å‡ç”µèŠ¯å¹³é¢ç‚¹ä½æœåŠ¡
        /// </summary>
        /// <remarks>
        /// ç”¨äºŽç®¡ç†å‡ç”µèŠ¯å¹³é¢ç‚¹ä½çš„分配和状态。
        /// </remarks>
        private readonly IFakeBatteryPositionService _fakeBatteryPositionService;

        /// <summary>
        /// æ—¥å¿—记录器
        /// </summary>
        private readonly ILogger _logger;
@@ -88,7 +96,8 @@
            IRobotTaskService robotTaskService,
            ITaskService taskService,
            HttpClientHelper httpClientHelper,
            ILogger logger)
            ILogger logger,
            IFakeBatteryPositionService fakeBatteryPositionService)
        {
            _socketClientGateway = socketClientGateway;
            _stateManager = stateManager;
@@ -96,6 +105,7 @@
            _taskService = taskService;
            _httpClientHelper = httpClientHelper;
            _logger = logger;
            _fakeBatteryPositionService = fakeBatteryPositionService;
        }

        /// <summary>
@@ -190,6 +200,74 @@
        }

        /// <summary>
        /// ä¸‹å‘假电芯取货指令到机器人客户端
        /// </summary>
        /// <remarks>
        /// å‘送格式：Pickbattery,5,{startPosition}-{endPosition}
        /// ä¾‹å¦‚：Pickbattery,5,1-3 è¡¨ç¤ºä»Žå‡ç”µèŠ¯ä½ç½®5抓取，平面点位1到3
        ///
        /// ä¸‹å‘成功后：
        /// 1. æ ‡è®°ç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// 2. æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸º"机器人执行中"
        /// 3. å®‰å…¨æ›´æ–°çŠ¶æ€åˆ° Redis
        /// </remarks>
        /// <param name="task">要下发的任务对象</param>
        /// <param name="state">机器人当前状态</param>
        /// <param name="positions">要抓取的平面点位列表</param>
        public async Task SendSocketRobotFakeBatteryPickAsync(Dt_RobotTask task, RobotSocketState state, List<int> positions)
        {
            if (positions == null || positions.Count == 0)
            {
                _logger.LogWarning("SendSocketRobotFakeBatteryPickAsync：平面点位列表为空，任务号: {TaskNum}", task.RobotTaskNum);
                return;
            }

            // è®¡ç®—点位范围，格式：1-3
            int startPos = positions.Min();
            int endPos = positions.Max();
            string taskString = $"Pickbattery,5,{startPos}-{endPos}";

            // æ ‡è®°ç‚¹ä½ä¸ºå·²ä½¿ç”¨
            _fakeBatteryPositionService.MarkAsUsed(positions);

            // é€šè¿‡ Socket ç½‘关发送指令到机器人客户端
            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            {
                _logger.LogInformation("下发假电芯取货指令成功，指令: {TaskString}，点位: {Positions}，设备: {DeviceName}",
                    taskString, string.Join(",", positions), state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发假电芯取货指令成功，指令: {taskString}", state.RobotCrane?.DeviceName);

                // æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸º"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

                // å°†ä»»åŠ¡å…³è”到状态对象
                state.CurrentTask = task;

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                _logger.LogError("下发假电芯取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发假电芯取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
            }
        }

        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表</returns>
        public List<int> GetNextAvailableFakeBatteryPositions(int count)
        {
            return _fakeBatteryPositionService.GetNextAvailable(count);
        }

        /// <summary>
        /// å¤„理入库任务回传（拆盘/组盘/换盘场景）
        /// </summary>
        /// <remarks>

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/RobotWorkflowOrchestrator.cs

@@ -237,13 +237,13 @@
                    || task.RobotTaskType == RobotTaskTypeEnum.ChangePallet.GetHashCode();
            }

            // å¦‚果是组盘任务（包括换盘）
            // å¦‚果是组盘任务
            if (task.RobotTaskType == RobotTaskTypeEnum.GroupPallet.GetHashCode())
            {
                // ç”Ÿæˆæ‰˜ç›˜æ¡ç å‰ç¼€
                const string prefix = "TRAY";

                // ç”Ÿæˆä¸¤ä¸ªæ‰˜ç›˜æ¡ç ï¼ˆç”¨äºŽç»„盘操作）
                // ç”Ÿæˆä¸¤ä¸ªæ‰˜ç›˜æ¡ç ï¼ˆç”¨äºŽç»„盘操作）（测试用，后续读取线体条码）
                string trayBarcode1 = RobotBarcodeGenerator.GenerateTrayBarcode(prefix);
                string trayBarcode2 = RobotBarcodeGenerator.GenerateTrayBarcode(prefix);

@@ -282,6 +282,66 @@
                    QuartzLogger.Error($"生成托盘条码失败", stateForUpdate.RobotCrane.DeviceName);
                }
            }
            else if (task.RobotTaskType == RobotTaskTypeEnum.ChangePallet.GetHashCode())
            {
                // æ¢ç›˜ä»»åŠ¡
                // ç›®æ ‡ï¼šæ­£å¸¸ç”µèŠ¯æŠ“取完成后，补充假电芯至48个
                const int targetTotal = 48;
                const int fakeBatteryPickPosition = 5;  // å‡ç”µèŠ¯æŠ“取位置
                const int pickCountPerExecution = 4;     // æ¯æ¬¡æŠ“取数量

                int targetNormalCount = task.RobotTaskTotalNum;  // æ­£å¸¸ç”µèŠ¯ç›®æ ‡æ•°é‡
                int currentCompletedCount = stateForUpdate.RobotTaskTotalNum;  // å·²å®Œæˆæ•°é‡

                // å¦‚果目标数量为48，直接下发正常任务
                if (targetNormalCount == targetTotal)
                {
                    await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate);
                }
                // å¦‚果已完成数量小于目标数量，继续抓取正常电芯
                else if (currentCompletedCount < targetNormalCount)
                {
                    await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate);
                }
                // æ­£å¸¸ç”µèŠ¯å·²å®Œæˆï¼Œè¿›å…¥å‡ç”µèŠ¯è¡¥å……模式
                else if (currentCompletedCount == targetNormalCount && !stateForUpdate.IsInFakeBatteryMode)
                {
                    // é¦–次进入假电芯模式，设置标志
                    stateForUpdate.IsInFakeBatteryMode = true;
                    _logger.LogInformation("HandlePutFinishedStateAsync：正常电芯抓取完成，进入假电芯补充模式，任务号: {TaskNum}", task.RobotTaskNum);
                    QuartzLogger.Info($"正常电芯抓取完成，进入假电芯补充模式", stateForUpdate.RobotCrane?.DeviceName);
                }

                // å¦‚果处于假电芯补充模式，计算并下发补数任务
                if (stateForUpdate.IsInFakeBatteryMode)
                {
                    int remaining = targetTotal - currentCompletedCount;
                    if (remaining > 0)
                    {
                        // è®¡ç®—每次抓取的数量（最多4个）
                        int pickCount = Math.Min(pickCountPerExecution, remaining);

                        // èŽ·å–可用的假电芯平面点位
                        var positions = _taskProcessor.GetNextAvailableFakeBatteryPositions(pickCount);
                        if (positions.Count == 0)
                        {
                            _logger.LogError("HandlePutFinishedStateAsync：无可用假电芯点位，任务号: {TaskNum}", task.RobotTaskNum);
                            QuartzLogger.Error($"无可用假电芯点位", stateForUpdate.RobotCrane?.DeviceName);
                            return;
                        }

                        // ä¸‹å‘假电芯取货指令
                        await _taskProcessor.SendSocketRobotFakeBatteryPickAsync(task, stateForUpdate, positions);
                    }
                    else
                    {
                        // å‡ç”µèŠ¯è¡¥å……完成，重置标志
                        stateForUpdate.IsInFakeBatteryMode = false;
                        _logger.LogInformation("HandlePutFinishedStateAsync：换盘任务完成，任务号: {TaskNum}", task.RobotTaskNum);
                        QuartzLogger.Info($"换盘任务完成", stateForUpdate.RobotCrane?.DeviceName);
                    }
                }
            }
            else
            {
                // éžç»„盘任务，直接发送取货指令

 Code/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Task/WMSTaskDTO.cs

@@ -67,6 +67,11 @@
        public int Grade { get; set; }

        /// <summary>
        /// ä»»åŠ¡æ•°é‡
        /// </summary>
        public int TaskQuantity { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public int WarehouseId { get; set; }

 Code/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/WCS/TaskService_Robot.cs

@@ -100,7 +100,7 @@
                    if (string.IsNullOrWhiteSpace(stockPalletCode))
                        return WebResponseContent.Instance.Error("源托盘号不能为空");

                    stockInfo = await _stockInfoService.GetStockInfoAsync(stockPalletCode);
                    stockInfo = await _stockInfoService.Repository.QueryDataNavFirstAsync(x => x.PalletCode == stockPalletCode);
                    if (stockInfo == null)
                        return WebResponseContent.Instance.Error($"托盘[{stockPalletCode}]库存不存在");

@@ -134,6 +134,7 @@
                    return WebResponseContent.Instance.Error($"机械手{taskName}任务创建失败");

                var wmstaskDto = _mapper.Map<WMSTaskDTO>(task) ?? new WMSTaskDTO();
                wmstaskDto.TaskQuantity = stock.Details?.Sum(d => d.Quantity) ?? 0;
                return WebResponseContent.Instance.OK($"机械手{taskName}任务创建成功", wmstaskDto);
            }
            catch (Exception ex)

 Code/docs/superpowers/plans/2026-04-15-change-pallet-fake-battery.md

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,640 @@
# æ¢ç›˜ä»»åŠ¡å‡ç”µèŠ¯è¡¥å……逻辑 Implementation 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:** åœ¨ `HandlePutFinishedStateAsync` ä¸­å®žçŽ°æ¢ç›˜ä»»åŠ¡çš„特殊逻辑：当 `task.RobotTaskTotalNum != 48` æ—¶ï¼Œæ­£å¸¸ç”µèŠ¯ä»»åŠ¡å®ŒæˆåŽéœ€è¡¥å……假电芯至48个。

**Architecture:** æ¢ç›˜ä»»åŠ¡åˆ†ä¸¤é˜¶æ®µæ‰§è¡Œï¼š(1) æ­£å¸¸ç”µèŠ¯æŠ“取阶段；(2) å‡ç”µèŠ¯è¡¥å……阶段。假电芯从位置5抓取，指令格式 `Pickbattery,5,1-3`。新增 `Dt_FakeBatteryPosition` è¡¨ç®¡ç†3×16平面点位的占用状态。

**Tech Stack:** C# / .NET 6, SqlSugar ORM, Redis缓存

---

## File Structure

```
WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/
  + Dt_FakeBatteryPosition.cs          # å‡ç”µèŠ¯å¹³é¢ç‚¹ä½è¡¨å®žä½“

WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoRepository/
  + IFakeBatteryPositionRepository.cs  # å‡ç”µèŠ¯ä½ç½®ä»“储接口

WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoRepository/
  + FakeBatteryPositionRepository.cs   # å‡ç”µèŠ¯ä½ç½®ä»“储实现

WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/
  + IFakeBatteryPositionService.cs     # å‡ç”µèŠ¯ä½ç½®æœåŠ¡æŽ¥å£

WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/
  + FakeBatteryPositionService.cs      # å‡ç”µèŠ¯ä½ç½®æœåŠ¡å®žçŽ°

WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/
  = RobotSocketState.cs                # +IsInFakeBatteryMode æ ‡å¿—
  = RobotTaskProcessor.cs              # +SendSocketRobotFakeBatteryPickAsync æ–¹æ³•

WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/
  = RobotWorkflowOrchestrator.cs      # å®žçŽ° ChangePallet åˆ†æ”¯å®Œæ•´é€»è¾‘
```

---

## Task 1: åˆ›å»ºå‡ç”µèŠ¯å¹³é¢ç‚¹ä½è¡¨å®žä½“

**Files:**
- Create: `WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/Dt_FakeBatteryPosition.cs`

- [ ] **Step 1: åˆ›å»º Dt_FakeBatteryPosition.cs**

```csharp
using SqlSugar;
using WIDESEAWCS_Core.DB.Models;

namespace WIDESEAWCS_Model.Models
{
    /// <summary>
    /// å‡ç”µèŠ¯å¹³é¢ç‚¹ä½è¡¨
    /// </summary>
    /// <remarks>
    /// ç”¨äºŽç®¡ç†å‡ç”µèŠ¯æŠ“取点的平面点位信息。
    /// 3行×16列布局，共48个点位（1-48），行优先排列。
    /// ç¬¬1行：1-16，第2行：17-32，第3行：33-48。
    /// </remarks>
    [SugarTable(nameof(Dt_FakeBatteryPosition), "假电芯平面点位表")]
    public class Dt_FakeBatteryPosition : BaseEntity
    {
        /// <summary>
        /// ä¸»é”®ID
        /// </summary>
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnDescription = "主键ID")]
        public int Id { get; set; }

        /// <summary>
        /// å¹³é¢ç‚¹ä½ç´¢å¼•ï¼ˆ1-48）
        /// </summary>
        /// <remarks>
        /// 3×16布局，行优先（1-16为第1行，17-32为第2行，33-48为第3行）。
        /// </remarks>
        [SugarColumn(ColumnDescription = "平面点位索引")]
        public int PositionIndex { get; set; }

        /// <summary>
        /// æ‰€åœ¨è¡Œï¼ˆ1-3）
        /// </summary>
        [SugarColumn(ColumnDescription = "所在行")]
        public int Row { get; set; }

        /// <summary>
        /// æ‰€åœ¨åˆ—（1-16）
        /// </summary>
        [SugarColumn(ColumnDescription = "所在列")]
        public int Col { get; set; }

        /// <summary>
        /// æ˜¯å¦å·²ä½¿ç”¨
        /// </summary>
        [SugarColumn(ColumnDescription = "是否已使用")]
        public bool IsUsed { get; set; }
    }
}
```

- [ ] **Step 2: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/Dt_FakeBatteryPosition.cs
git commit -m "feat(Robot): æ·»åŠ å‡ç”µèŠ¯å¹³é¢ç‚¹ä½è¡¨å®žä½“ Dt_FakeBatteryPosition"
```

---

## Task 2: åˆ›å»ºå‡ç”µèŠ¯ä½ç½®ä»“储层

**Files:**
- Create: `WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoRepository/IFakeBatteryPositionRepository.cs`
- Create: `WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoRepository/FakeBatteryPositionRepository.cs`

- [ ] **Step 1: åˆ›å»º IFakeBatteryPositionRepository.cs**

```csharp
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_ITaskInfoRepository
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®ä»“储接口
    /// </summary>
    public interface IFakeBatteryPositionRepository : IRepository<Dt_FakeBatteryPosition>
    {
        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表，按PositionIndex升序</returns>
        List<int> GetNextAvailable(int count);

        /// <summary>
        /// é‡ç½®æ‰€æœ‰ç‚¹ä½ä¸ºæœªä½¿ç”¨
        /// </summary>
        /// <returns>影响的行数</returns>
        int ResetAll();

        /// <summary>
        /// æ ‡è®°æŒ‡å®šç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// </summary>
        /// <param name="positions">点位索引列表</param>
        /// <returns>是否成功</returns>
        bool MarkAsUsed(List<int> positions);

        /// <summary>
        /// æ ¹æ®è¡Œå’Œåˆ—获取点位索引
        /// </summary>
        /// <param name="row">行（1-3）</param>
        /// <param name="col">列（1-16）</param>
        /// <returns>点位索引（1-48），找不到返回null</returns>
        int? GetPositionIndex(int row, int col);
    }
}
```

- [ ] **Step 2: åˆ›å»º FakeBatteryPositionRepository.cs**

```csharp
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_TaskInfoRepository
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®ä»“储实现
    /// </summary>
    public class FakeBatteryPositionRepository : RepositoryBase<Dt_FakeBatteryPosition>, IFakeBatteryPositionRepository
    {
        public FakeBatteryPositionRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
        {
        }

        /// <inheritdoc/>
        public List<int> GetNextAvailable(int count)
        {
            return Db.Queryable<Dt_FakeBatteryPosition>()
                .Where(x => !x.IsUsed)
                .OrderBy(x => x.PositionIndex)
                .Take(count)
                .Select(x => x.PositionIndex)
                .ToList();
        }

        /// <inheritdoc/>
        public int ResetAll()
        {
            return Db.Updateable<Dt_FakeBatteryPosition>()
                .SetColumns(x => x.IsUsed, false)
                .ExecuteCommand();
        }

        /// <inheritdoc/>
        public bool MarkAsUsed(List<int> positions)
        {
            if (positions == null || positions.Count == 0)
                return true;

            return Db.Updateable<Dt_FakeBatteryPosition>()
                .SetColumns(x => x.IsUsed, true)
                .Where(x => positions.Contains(x.PositionIndex))
                .ExecuteCommand() > 0;
        }

        /// <inheritdoc/>
        public int? GetPositionIndex(int row, int col)
        {
            return Db.Queryable<Dt_FakeBatteryPosition>()
                .Where(x => x.Row == row && x.Col == col)
                .Select(x => x.PositionIndex)
                .FirstOrDefault();
        }
    }
}
```

- [ ] **Step 3: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoRepository/IFakeBatteryPositionRepository.cs
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoRepository/FakeBatteryPositionRepository.cs
git commit -m "feat(Robot): æ·»åŠ å‡ç”µèŠ¯ä½ç½®ä»“储层"
```

---

## Task 3: åˆ›å»ºå‡ç”µèŠ¯ä½ç½®æœåŠ¡å±‚

**Files:**
- Create: `WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/IFakeBatteryPositionService.cs`
- Create: `WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/FakeBatteryPositionService.cs`

- [ ] **Step 1: åˆ›å»º IFakeBatteryPositionService.cs**

```csharp
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_ITaskInfoService
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®æœåŠ¡æŽ¥å£
    /// </summary>
    public interface IFakeBatteryPositionService : IService<Dt_FakeBatteryPosition>
    {
        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表，按PositionIndex升序</returns>
        List<int> GetNextAvailable(int count);

        /// <summary>
        /// é‡ç½®æ‰€æœ‰ç‚¹ä½ä¸ºæœªä½¿ç”¨
        /// </summary>
        /// <returns>影响的行数</returns>
        int ResetAll();

        /// <summary>
        /// æ ‡è®°æŒ‡å®šç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// </summary>
        /// <param name="positions">点位索引列表</param>
        /// <returns>是否成功</returns>
        bool MarkAsUsed(List<int> positions);

        /// <summary>
        /// æ ¹æ®è¡Œå’Œåˆ—获取点位索引
        /// </summary>
        /// <param name="row">行（1-3）</param>
        /// <param name="col">列（1-16）</param>
        /// <returns>点位索引（1-48），找不到返回null</returns>
        int? GetPositionIndex(int row, int col);

        /// <summary>
        /// åˆå§‹åŒ–假电芯点位表（48个点位）
        /// </summary>
        /// <remarks>
        /// ä»…当表为空时插入1-48的初始数据。
        /// 3行×16列，行优先排列。
        /// </remarks>
        /// <returns>是否成功</returns>
        bool InitializeIfEmpty();
    }
}
```

- [ ] **Step 2: åˆ›å»º FakeBatteryPositionService.cs**

```csharp
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_TaskInfoService
{
    /// <summary>
    /// å‡ç”µèŠ¯ä½ç½®æœåŠ¡å®žçŽ°
    /// </summary>
    public class FakeBatteryPositionService : ServiceBase<Dt_FakeBatteryPosition, IFakeBatteryPositionRepository>, IFakeBatteryPositionService
    {
        public FakeBatteryPositionService(IFakeBatteryPositionRepository BaseDal) : base(BaseDal)
        {
        }

        /// <inheritdoc/>
        public List<int> GetNextAvailable(int count)
        {
            return BaseDal.GetNextAvailable(count);
        }

        /// <inheritdoc/>
        public int ResetAll()
        {
            return BaseDal.ResetAll();
        }

        /// <inheritdoc/>
        public bool MarkAsUsed(List<int> positions)
        {
            return BaseDal.MarkAsUsed(positions);
        }

        /// <inheritdoc/>
        public int? GetPositionIndex(int row, int col)
        {
            return BaseDal.GetPositionIndex(row, col);
        }

        /// <inheritdoc/>
        public bool InitializeIfEmpty()
        {
            var existing = BaseDal.QueryFirst(x => true);
            if (existing != null)
                return true;

            // ç”Ÿæˆ48个点位：3行×16列，行优先
            var positions = new List<Dt_FakeBatteryPosition>();
            for (int row = 1; row <= 3; row++)
            {
                for (int col = 1; col <= 16; col++)
                {
                    int positionIndex = (row - 1) * 16 + col;
                    positions.Add(new Dt_FakeBatteryPosition
                    {
                        PositionIndex = positionIndex,
                        Row = row,
                        Col = col,
                        IsUsed = false,
                        Creater = "System"
                    });
                }
            }

            return BaseDal.AddData(positions) > 0;
        }
    }
}
```

- [ ] **Step 3: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/IFakeBatteryPositionService.cs
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/FakeBatteryPositionService.cs
git commit -m "feat(Robot): æ·»åŠ å‡ç”µèŠ¯ä½ç½®æœåŠ¡å±‚"
```

---

## Task 4: ä¿®æ”¹ RobotSocketState æ·»åŠ  IsInFakeBatteryMode æ ‡å¿—

**Files:**
- Modify: `WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotSocketState.cs:175` (在 `RobotTaskTotalNum` å±žæ€§åŽæ·»åŠ )

- [ ] **Step 1: æ·»åŠ  IsInFakeBatteryMode å±žæ€§**

在 `RobotSocketState.cs` çš„ `RobotTaskTotalNum` å±žæ€§åŽæ·»åŠ ï¼š

```csharp
        /// <summary>
        /// æœºå™¨äººå·²å¤„理的任务总数
        /// </summary>
        public int RobotTaskTotalNum { get; set; }

        /// <summary>
        /// æ˜¯å¦å¤„于假电芯补充模式
        /// </summary>
        /// <remarks>
        /// å½“正常电芯任务完成后设为 true，机器人从假电芯位置补充电芯至48个。
        /// </remarks>
        public bool IsInFakeBatteryMode { get; set; }
```

- [ ] **Step 2: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotSocketState.cs
git commit -m "feat(Robot): RobotSocketState æ·»åŠ  IsInFakeBatteryMode æ ‡å¿—"
```

---

## Task 5: ä¿®æ”¹ RobotTaskProcessor æ·»åŠ å‡ç”µèŠ¯å–货指令方法

**Files:**
- Modify: `WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs` (在 `SendSocketRobotPickAsync` åŽæ·»åŠ æ–°æ–¹æ³•)

- [ ] **Step 1: æ·»åŠ  IFakeBatteryPositionService ä¾èµ–**

在 `RobotTaskProcessor` æž„造函数中添加：

```csharp
private readonly IFakeBatteryPositionService _fakeBatteryPositionService;

// æž„造函数参数中添加：
, IFakeBatteryPositionService fakeBatteryPositionService

// æž„造函数赋值：
_fakeBatteryPositionService = fakeBatteryPositionService;
```

- [ ] **Step 2: æ·»åŠ  SendSocketRobotFakeBatteryPickAsync æ–¹æ³•**

在 `SendSocketRobotPickAsync` æ–¹æ³•åŽæ·»åŠ ï¼š

```csharp
        /// <summary>
        /// ä¸‹å‘假电芯取货指令到机器人客户端
        /// </summary>
        /// <remarks>
        /// å‘送格式：Pickbattery,5,{startPosition}-{endPosition}
        /// ä¾‹å¦‚：Pickbattery,5,1-3 è¡¨ç¤ºä»Žå‡ç”µèŠ¯ä½ç½®5抓取，平面点位1到3
        ///
        /// ä¸‹å‘成功后：
        /// 1. æ ‡è®°ç‚¹ä½ä¸ºå·²ä½¿ç”¨
        /// 2. æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸º"机器人执行中"
        /// 3. å®‰å…¨æ›´æ–°çŠ¶æ€åˆ° Redis
        /// </remarks>
        /// <param name="task">要下发的任务对象</param>
        /// <param name="state">机器人当前状态</param>
        /// <param name="positions">要抓取的平面点位列表</param>
        public async Task SendSocketRobotFakeBatteryPickAsync(Dt_RobotTask task, RobotSocketState state, List<int> positions)
        {
            if (positions == null || positions.Count == 0)
            {
                _logger.LogWarning("SendSocketRobotFakeBatteryPickAsync：平面点位列表为空，任务号: {TaskNum}", task.RobotTaskNum);
                return;
            }

            // è®¡ç®—点位范围，格式：1-3
            int startPos = positions.Min();
            int endPos = positions.Max();
            string taskString = $"Pickbattery,5,{startPos}-{endPos}";

            // æ ‡è®°ç‚¹ä½ä¸ºå·²ä½¿ç”¨
            _fakeBatteryPositionService.MarkAsUsed(positions);

            // é€šè¿‡ Socket ç½‘关发送指令到机器人客户端
            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            {
                _logger.LogInformation("下发假电芯取货指令成功，指令: {TaskString}，点位: {Positions}，设备: {DeviceName}",
                    taskString, string.Join(",", positions), state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发假电芯取货指令成功，指令: {taskString}", state.RobotCrane?.DeviceName);

                // æ›´æ–°ä»»åŠ¡çŠ¶æ€ä¸º"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

                // å°†ä»»åŠ¡å…³è”到状态对象
                state.CurrentTask = task;

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                _logger.LogError("下发假电芯取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发假电芯取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
            }
        }
```

- [ ] **Step 3: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs
git commit -m "feat(Robot): RobotTaskProcessor æ·»åŠ å‡ç”µèŠ¯å–货指令方法"
```

---

## Task 6: å®žçŽ° HandlePutFinishedStateAsync ä¸­çš„ ChangePallet å®Œæ•´é€»è¾‘

**Files:**
- Modify: `WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/RobotWorkflowOrchestrator.cs:285-300`

- [ ] **Step 1: å®žçŽ° ChangePallet åˆ†æ”¯é€»è¾‘**

将现有的占位代码替换为：

```csharp
            else if (task.RobotTaskType == RobotTaskTypeEnum.ChangePallet.GetHashCode())
            {
                // æ¢ç›˜ä»»åŠ¡
                // ç›®æ ‡ï¼šæ­£å¸¸ç”µèŠ¯æŠ“取完成后，补充假电芯至48个
                const int targetTotal = 48;
                const int fakeBatteryPickPosition = 5;  // å‡ç”µèŠ¯æŠ“取位置
                const int pickCountPerExecution = 4;     // æ¯æ¬¡æŠ“取数量

                int targetNormalCount = task.RobotTaskTotalNum;  // æ­£å¸¸ç”µèŠ¯ç›®æ ‡æ•°é‡
                int currentCompletedCount = stateForUpdate.RobotTaskTotalNum;  // å·²å®Œæˆæ•°é‡

                // å¦‚果目标数量为48，直接下发正常任务
                if (targetNormalCount == targetTotal)
                {
                    await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate);
                }
                // å¦‚果已完成数量小于目标数量，继续抓取正常电芯
                else if (currentCompletedCount < targetNormalCount)
                {
                    await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate);
                }
                // æ­£å¸¸ç”µèŠ¯å·²å®Œæˆï¼Œè¿›å…¥å‡ç”µèŠ¯è¡¥å……模式
                else if (currentCompletedCount == targetNormalCount && !stateForUpdate.IsInFakeBatteryMode)
                {
                    // é¦–次进入假电芯模式，设置标志
                    stateForUpdate.IsInFakeBatteryMode = true;
                    _logger.LogInformation("HandlePutFinishedStateAsync：正常电芯抓取完成，进入假电芯补充模式，任务号: {TaskNum}", task.RobotTaskNum);
                    QuartzLogger.Info($"正常电芯抓取完成，进入假电芯补充模式", stateForUpdate.RobotCrane?.DeviceName);
                }

                // å¦‚果处于假电芯补充模式，计算并下发补数任务
                if (stateForUpdate.IsInFakeBatteryMode)
                {
                    int remaining = targetTotal - currentCompletedCount;
                    if (remaining > 0)
                    {
                        // è®¡ç®—每次抓取的数量（最多4个）
                        int pickCount = Math.Min(pickCountPerExecution, remaining);

                        // èŽ·å–可用的假电芯平面点位
                        var positions = _taskProcessor.GetNextAvailableFakeBatteryPositions(pickCount);
                        if (positions.Count == 0)
                        {
                            _logger.LogError("HandlePutFinishedStateAsync：无可用假电芯点位，任务号: {TaskNum}", task.RobotTaskNum);
                            QuartzLogger.Error($"无可用假电芯点位", stateForUpdate.RobotCrane?.DeviceName);
                            return;
                        }

                        // ä¸‹å‘假电芯取货指令
                        await _taskProcessor.SendSocketRobotFakeBatteryPickAsync(task, stateForUpdate, positions);
                    }
                    else
                    {
                        // å‡ç”µèŠ¯è¡¥å……完成，重置标志
                        stateForUpdate.IsInFakeBatteryMode = false;
                        _logger.LogInformation("HandlePutFinishedStateAsync：换盘任务完成，任务号: {TaskNum}", task.RobotTaskNum);
                        QuartzLogger.Info($"换盘任务完成", stateForUpdate.RobotCrane?.DeviceName);
                    }
                }
            }
```

- [ ] **Step 2: åœ¨ RobotTaskProcessor ä¸­æ·»åŠ  GetNextAvailableFakeBatteryPositions è¾…助方法**

在 `RobotTaskProcessor` ä¸­æ·»åŠ ï¼š

```csharp
        /// <summary>
        /// èŽ·å–下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表</returns>
        public List<int> GetNextAvailableFakeBatteryPositions(int count)
        {
            return _fakeBatteryPositionService.GetNextAvailable(count);
        }
```

- [ ] **Step 3: Commit**

```bash
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/RobotWorkflowOrchestrator.cs
git add WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs
git commit -m "feat(Robot): å®žçŽ°æ¢ç›˜ä»»åŠ¡å‡ç”µèŠ¯è¡¥å……逻辑"
```

---

## Task 7: éªŒè¯æž„建

- [ ] **Step 1: è¿è¡Œ dotnet build**

```bash
dotnet build WCS/WIDESEAWCS_Server/WIDESEAWCS_Server.sln
```

- [ ] **Step 2: æ£€æŸ¥æ˜¯å¦æœ‰ç¼–译错误**

---

## é™„录：数据库初始化SQL

```sql
-- åˆå§‹åŒ–假电芯平面点位表（48个点位：3行×16列，行优先）
-- ç¬¬1行：1-16，第2行：17-32，第3行：33-48
IF NOT EXISTS (SELECT 1 FROM Dt_FakeBatteryPosition)
BEGIN
    INSERT INTO Dt_FakeBatteryPosition (PositionIndex, Row, Col, IsUsed, Creater, CreateDate)
    SELECT
        ((row - 1) * 16 + col) AS PositionIndex,
        row AS Row,
        col AS Col,
        0 AS IsUsed,
        'System' AS Creater,
        GETDATE() AS CreateDate
    FROM (SELECT 1 AS row UNION SELECT 2 UNION SELECT 3) AS rows
    CROSS JOIN (SELECT 1 AS col UNION SELECT 2 UNION SELECT 3 UNION SELECT 4 UNION SELECT 5 UNION SELECT 6
                UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 UNION SELECT 10 UNION SELECT 11 UNION SELECT 12
                UNION SELECT 13 UNION SELECT 14 UNION SELECT 15 UNION SELECT 16) AS cols
    ORDER BY row, col;
END
```

---

**Plan complete and saved to `docs/superpowers/plans/2026-04-15-change-pallet-fake-battery.md`. Two execution options:**

**1. Subagent-Driven (recommended)** - I dispatch a fresh subagent per task, review between tasks, fast iteration

**2. Inline Execution** - Execute tasks in this session using executing-plans, batch execution with checkpoints

**Which approach?**