test('Task 新字段默认值', () => {
  const store = new Store(':memory:');
  const p = store.createProject({ name:'p', repoPath:'/tmp/t-'+Math.random(), autonomy:'manual' });
  const t = store.createTask({ projectId: p.id, title:'feat', complexity:'easy' });
  assert.strictEqual(t.scheduleStatus, 'init');
  assert.deepStrictEqual(t.workPlan, []);
  assert.strictEqual(t.version, 1);
});

tsx --test test/store.test.ts 2>&1 | grep -E "fail|Error" | head -5

  schedule_status   TEXT NOT NULL DEFAULT 'init',
  work_type         TEXT,
  work_plan         TEXT NOT NULL DEFAULT '[]',
  work_history      TEXT NOT NULL DEFAULT '[]',
  claimed_at        TEXT,
  version           INTEGER NOT NULL DEFAULT 1,
  scope             TEXT,
  owned_files       TEXT NOT NULL DEFAULT '[]',
  expected_output   TEXT
  -- runs 表：
  trace_id          TEXT

  ensureColumn(db,'tasks','schedule_status',"schedule_status TEXT NOT NULL DEFAULT 'init'");
  ensureColumn(db,'tasks','work_type','work_type TEXT');
  ensureColumn(db,'tasks','work_plan',"work_plan TEXT NOT NULL DEFAULT '[]'");
  ensureColumn(db,'tasks','work_history',"work_history TEXT NOT NULL DEFAULT '[]'");
  ensureColumn(db,'tasks','claimed_at','claimed_at TEXT');
  ensureColumn(db,'tasks','version','version INTEGER NOT NULL DEFAULT 1');
  ensureColumn(db,'tasks','scope','scope TEXT');
  ensureColumn(db,'tasks','owned_files',"owned_files TEXT NOT NULL DEFAULT '[]'");
  ensureColumn(db,'tasks','expected_output','expected_output TEXT');
  ensureColumn(db,'runs','trace_id','trace_id TEXT');

export type ScheduleStatus = 'init'|'ready'|'running'|'waiting'|'blocked'|'paused'|'failed'|'stuck'|'done'|'cancelled';
export type WorkType = 'plan'|'code'|'review'|'pr'|'conflict'|'research';
export type TaskScope = 'file'|'module'|'service'|'cross-service';
export interface WorkStep { type: WorkType; spec?: string; ownedFiles?: string[]; expectedOutput?: string; }
// Task 接口追加：
  scheduleStatus: ScheduleStatus; workType: WorkType|null;
  workPlan: WorkStep[]; workHistory: WorkStep[];
  scope: TaskScope|null; ownedFiles: string[]; expectedOutput: string|null;
  claimedAt: string|null; version: number;

// TaskRow 追加：
  schedule_status:string; work_type:string|null; work_plan:string; work_history:string; owned_files:string; claimed_at:string|null; version:number;
// rowToTask 追加：
  scheduleStatus: r.schedule_status ?? 'init',
  workType: r.work_type ?? null,
  workPlan: r.work_plan ? JSON.parse(r.work_plan) : [],
  workHistory: r.work_history ? JSON.parse(r.work_history) : [],
  ownedFiles: r.owned_files ? JSON.parse(r.owned_files) : [],
  version: r.version ?? 1,

npm test 2>&1 | tail -15

npm run typecheck

git add src/store/schema.sql src/store/db.ts src/model/types.ts src/store/mappers.ts src/store/store.ts test/store.test.ts
git commit -m "feat(model): 新增 scheduleStatus/workType/workPlan/workHistory/scope/version 字段 + schema 迁移"

test('CAS — 同任务不能双重领取', () => {
  assert.ok(store.casClaimTask(task.id,'run-1'));
  assert.ok(!store.casClaimTask(task.id,'run-2'));
});
test('transition→ready 清空 claimed_at', () => {
  store.decide(task.id,'reject','human','改');
  assert.ok(store.casClaimTask(task.id,'run-3'));
});

tsx --test test/orchestrator.test.ts 2>&1 | grep casClaimTask | head -3

casClaimTask(taskId:string,_runId:string):boolean {
  const r=this.db.prepare(
    `UPDATE tasks SET claimed_at=?,updated_at=? WHERE id=? AND claimed_at IS NULL`
  ).run(now(),now(),taskId);
  return r.changes===1;
}

if(to==='ready'){
  this.db.prepare(`UPDATE tasks SET status=?,claimed_at=NULL,updated_at=? WHERE id=?`).run(to,now(),taskId);
}

if(!store.casClaimTask(task.id,run.id)){log.error(`CAS失败`);return;}

private assertNoActiveRun(taskId:string){
  const {n}=this.db.prepare(`SELECT COUNT(*) n FROM runs WHERE task_id=? AND status='started'`).get(taskId) as {n:number};
  if(n>0) throw new StoreError('任务执行中，禁止修改');
}

test('执行中禁止修改 spec', () => {
  store.startRun(t.id,'planner');
  assert.throws(()=>store.setSpec(t.id,'x'),/执行中/);
});

npm test 2>&1 | tail -15

npm run typecheck

git add src/store/store.ts src/daemon/orchestrator.ts test/orchestrator.test.ts
git commit -m "feat(store): CAS claimed_at 防双重 claim + 执行期锁"

test('agingBonus — 新建任务为 0', () =>
  assert.strictEqual(agingBonus({createdAt:new Date().toISOString(),priority:1} as Task,Date.now()),0));
test('couplingPenalty — 1个重叠=-0.5', () =>
  assert.strictEqual(couplingPenalty({ownedFiles:['a.ts','b.ts']} as Task,[{ownedFiles:['a.ts']} as Task]),0.5));

tsx --test test/orchestrator.test.ts 2>&1 | grep -E "agingBonus|coupling" | head -3

export function rankU(id:string,byId:Map<string,Task>,deps:Map<string,Task[]>,cache:Map<string,number>):number{
  if(cache.has(id))return cache.get(id)!;
  const t=byId.get(id); if(!t){cache.set(id,0);return 0;}
  const v=baseScore(t.priority)+(deps.get(id)??[]).reduce((s,d)=>s+rankU(d.id,byId,deps,cache),0);
  cache.set(id,v);return v;
}
export const agingBonus=(t:Task,nowMs:number)=>
  Math.min(baseScore(t.priority),(nowMs-Date.parse(t.createdAt))/3_600_000/48);
export function couplingPenalty(t:Task,inFlight:Task[]):number{
  const s=new Set(t.ownedFiles??[]); if(!s.size)return 0;
  let n=0; for(const x of inFlight)for(const f of(x.ownedFiles??[])) if(s.has(f))n++;
  return n*0.5;
}

const inflightList=tasks.filter(t=>inflight.has(t.id));
return rankByScore(candidates,tasks,inflightList,d.nowMs());

npm test 2>&1 | tail -15

npm run typecheck

git add src/model/scoring.ts src/daemon/orchestrator.ts test/orchestrator.test.ts
git commit -m "feat(scoring): CPM rankU + agingBonus + couplingPenalty 调度算法"

test('planner hard = opus-4-8', () =>
  assert.strictEqual(pickModel({complexity:'hard'}as Task,{model:null}as Project,'planner'),'claude-opus-4-8'));
test('reviewer 不被 project.model 降档', () =>
  assert.strictEqual(pickModel({complexity:'easy'}as Task,{model:'claude-sonnet-4-6'}as Project,'reviewer'),'claude-opus-4-8'));
test('MODEL_FALLBACK_CHAIN[0] = opus-4-8', () =>
  assert.strictEqual(MODEL_FALLBACK_CHAIN[0],'claude-opus-4-8'));

tsx --test test/models.test.ts 2>&1 | grep -E 'opus|reviewer' | head -3

// 1. 回退链（fable-5 暂不可用，opus-4-8 为最强档）
export const MODEL_FALLBACK_CHAIN=['claude-opus-4-8','claude-sonnet-4-6'] as const;
// 2. planner 分档：easy=sonnet，medium/hard=opus（hard 不再与 easy 同档）
  hard:['MAESTRO_MODEL_PLAN_HARD','claude-opus-4-8'],
// 3. reviewer 三档统一最强 opus-4-8（不被 project.model 降档）
  reviewer:{easy:[...,'claude-opus-4-8'],medium:[...,'claude-opus-4-8'],hard:[...,'claude-opus-4-8']},
// 4. conflict 固定最强（pickModel 首行）
if(role==='conflict')return 'claude-opus-4-8';

npm test 2>&1 | tail -15

npm run typecheck

git add src/executor/models.ts test/models.test.ts
git commit -m "feat(models): 复审/解冲突/planner-hard 统一最强档 opus-4-8"

test('decompose-result — ownedFiles 落入子任务', () => {
  appendOutbox(run.id,{type:'decompose-result',plan:'x',
    subtasks:[{title:'类型',complexity:'easy',priority:0,deps:[],
      ownedFiles:['src/model/types.ts'],expectedOutput:'typecheck通过'}]});
  ingestRun(store,noopLog,run.id);
  const [child]=store.childrenOf(parent.id);
  assert.deepStrictEqual(child.ownedFiles,['src/model/types.ts']);
  assert.strictEqual(child.expectedOutput,'typecheck通过');
});

tsx --test test/ingest.test.ts 2>&1 | grep -E "ownedFiles|expectedOutput" | head -3

subtasks: Array<{title:string;complexity:Complexity;priority?:number;deps?:number[];
  ownedFiles?:string[];expectedOutput?:string}>;

'- ownedFiles：主要修改文件路径 JSON string[]（无则填 []）',
'- expectedOutput：一句话可验证完成标准（如："typecheck通过"）'

for(let i=0;i<rec.subtasks.length;i++){
  const sub=rec.subtasks[i] as {ownedFiles?:string[];expectedOutput?:string};
  if(!createdIds[i])continue;
  const patch:Record<string,unknown>={};
  if(Array.isArray(sub.ownedFiles)&&sub.ownedFiles.length) patch.ownedFiles=sub.ownedFiles;
  if(typeof sub.expectedOutput==='string'&&sub.expectedOutput.trim()) patch.expectedOutput=sub.expectedOutput.trim();
  if(Object.keys(patch).length) store.patchTask(createdIds[i],patch);
}

npm test 2>&1 | tail -15

npm run typecheck

git add src/executor/runner.ts src/executor/protocol.ts src/daemon/ingest.ts test/ingest.test.ts
git commit -m "feat(planner): decompose JSON 扩展 ownedFiles/expectedOutput"

test('checks — lint 失败阻止 exec_review', async () => {
  job.project.checks=JSON.stringify({lint:'exit 1'});
  const emitted=[];
  await runPipeline(job,mockDeps,p=>emitted.push(p));
  assert.ok(emitted.find(e=>e.type==='failed'&&e.error.includes('lint')));
});
test('diff 体量闸 — 超 diffMaxFiles 失败', async () => {
  job.project.diffMaxFiles=2;
  mockDeps.worktreeDiff=async()=>({diffSummary:' a.ts | 1\n b.ts | 1\n c.ts | 1',commits:[]});
  const emitted=[];
  await runPipeline(job,mockDeps,p=>emitted.push(p));
  assert.ok(emitted.find(e=>e.type==='failed'));
});

tsx --test test/pipeline.test.ts 2>&1 | grep -E "diff|checks" | head -3

-- schema.sql：
  diff_max_files INTEGER NOT NULL DEFAULT 100
-- db.ts：
  ensureColumn(db,'projects','diff_max_files','diff_max_files INTEGER NOT NULL DEFAULT 100');

// types.ts： diffMaxFiles: number;
// rowToProject： diffMaxFiles: r.diff_max_files ?? 100,

runCheck?: (cmd:string, cwd:string) => void;

if(job.project.checks){
  let obj={}; try{obj=JSON.parse(job.project.checks)}catch{}
  for(const [name,cmd] of Object.entries(obj as Record<string,string>)){
    try{ (deps.runCheck??defaultRunCheck)(cmd,wt.dir); }
    catch(e){ emit({type:'failed',error:`[${name}]失败`,...}); return; }
  }
}

const maxF=job.project.diffMaxFiles??100;
if(maxF>0){
  const fc=diff.diffSummary.split('\n').filter(l=>l.includes('|')).length;
  if(fc>maxF){ emit({type:'failed',error:`diff超限:${fc}>${maxF}文件`,...}); return; }
}

npm test 2>&1 | tail -15

npm run typecheck && npm run build

git add src/executor/pipeline.ts src/store/schema.sql src/store/db.ts src/model/types.ts src/store/mappers.ts test/pipeline.test.ts
git commit -m "feat(pipeline): checks 分项闸 + diff 体量闸 (diffMaxFiles)"