// Scratch proof: run from current main's scenario harness; no production code changes.
import * as fs from "node:fs/promises";
import * as path from "node:path";
import * as http from "node:http";
import { randomUUID } from "node:crypto";
import { spawn } from "node:child_process";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import { APP_DIR, T3_HOME } from "../e2e.config.ts";
import { makeState, rpcClient, runPromise, test, WEB } from "./t3.ts";

const AGENT = String.raw`
import { createInterface } from 'node:readline';
import { spawn } from 'node:child_process';
import { randomUUID } from 'node:crypto';
const origin = process.argv[2];
let sessionId, mcp, count = 0;
const requests=new Map();
const request=(method,params)=>new Promise(resolve=>{const id=randomUUID();requests.set(id,resolve);send({id,method,params});});
const send = x => process.stdout.write(JSON.stringify({jsonrpc:'2.0',...x})+'\n');
const control = async (event, data={}) => (await fetch(origin+'/'+event,{method:'POST',body:JSON.stringify(data)})).json();
async function call(name,args) {
  const env = Object.fromEntries(mcp.env.map(e=>[e.name,e.value]));
  let sid;
  async function rpc(method,params) {
    const res=await fetch(env.T3_ACP_MCP_ENDPOINT,{method:'POST',headers:{'Content-Type':'application/json',Accept:'application/json, text/event-stream',Authorization:env.T3_ACP_MCP_AUTHORIZATION,...(sid?{'mcp-session-id':sid}: {})},body:JSON.stringify({jsonrpc:'2.0',id:randomUUID(),method,params})});
    sid=res.headers.get('mcp-session-id')??sid;
    const text=await res.text();
    const data=text.startsWith('data:')||text.startsWith('event:') ? text.split('\n').filter(l=>l.startsWith('data:')).map(l=>JSON.parse(l.slice(5))).find(x=>x.result||x.error):JSON.parse(text);
    if(data?.error) throw Error(JSON.stringify(data.error));
    return data.result;
  }
  await rpc('initialize',{protocolVersion:'2025-06-18',capabilities:{},clientInfo:{name:'proof-replay',version:'1'}});
  const result=await rpc('tools/call',{name,arguments:args});
  if(result.isError) throw Error(JSON.stringify(result));
  return result;
}
function output(text) {send({method:'session/update',params:{sessionId,update:{sessionUpdate:'agent_message_chunk',content:{type:'text',text}}}});}
async function handle(r) {
 const {method,params={},id}=r;
 if(method==='initialize') return {protocolVersion:1,agentCapabilities:{loadSession:true,promptCapabilities:{embeddedContext:true}},authMethods:[],agentInfo:{name:'hermes-agent',version:'1'}};
 if(method==='session/new'||method==='session/load') { sessionId=params.sessionId??randomUUID(); mcp=params.mcpServers?.find(s=>s.name==='t3-code'); return method==='session/new'?{sessionId}:{}; }
 if(method==='session/set_model'||method==='session/set_mode'||method==='authenticate') return {};
 if(method==='session/prompt') {
  count++;
  const text=params.prompt.filter(x=>x.type==='text').map(x=>x.text).join('\n');
  const setup=/PROOF_PARENT:(\w+)/.exec(text);
  const child=/PROOF_CHILD:(\w+)/.exec(text);
  if(setup) {
    const caseName=setup[1];
    const result=await call('delegate_task',{task:'PROOF_CHILD:'+caseName,title:'Inspect sample',mode:'async',target:{providerInstanceId:'proof-background',model:'claude-haiku-5-5'}});
    await control('delegated',{caseName,result});
    output('Delegated inspection. Waiting for the result.');
  } else if(child) {
    const caseName=child[1];
    if(caseName==='repeat') {
      for(const phase of ['repeat','changed']) {
        const taskId=randomUUID();
        send({method:'session/update',params:{sessionId,update:{sessionUpdate:'tool_call',toolCallId:taskId,title:'Background inspection ('+phase+')',kind:'execute',status:'completed',rawInput:{command:'inspect sample',block_until_ms:0},rawOutput:{type:'BackgroundTaskStarted',task_id:taskId,task_type:'bash',status:'running',command:'inspect sample',summary:'Inspection command is still running.'}}}});
        const command=spawn(process.execPath,['-e',"fetch(process.argv[1],{method:'POST'}).then(r=>r.text()).then(()=>console.log('Background inspection finished.'))",origin+'/background/'+phase],{stdio:'ignore'});
        command.on('exit',async()=>{
          send({method:'_x.ai/task_completed',params:{sessionId,update:{sessionUpdate:'task_completed',task_snapshot:{task_id:taskId,command:'inspect sample',kind:'bash',output:'Inspection command exited.',exit_code:0},will_wake:true}}});
          output(phase==='repeat'?'Inspection complete: sample is clean.':'Inspection complete: sample needs repair.');
          send({method:'session/update',params:{sessionId,update:{sessionUpdate:'session_info_update',title:'Inspect sample'}}});
          await control('selfstarted',{phase,sessionId});
        });
        process.on('exit',()=>command.kill());
      }

    }
    await control('child',{caseName,sessionId});
    output('Inspection complete: sample is clean.');
  } else {
    const state=await control('prompt',{sessionId,text});
    if(state.before) await control('hold',{sessionId});
    output(state.resume ? 'Continuing the interrupted turn after the server restart.' : state.child ? state.changed?'Inspection complete: sample needs repair.':'Inspection complete: sample is clean.' : 'Parent received result '+state.number+'.\n\n'+text.slice(text.indexOf('Delegated task ')).split(/<\/user_request>|<runtime_info>|\n\n\[T3/)[0].trim());
    if(state.after) await control('hold',{sessionId});
    await control('answered',{sessionId});
  }
  return {stopReason:'end_turn'};
 }
 return {};
}
createInterface({input:process.stdin}).on('line',line=>{
 const r=JSON.parse(line); if(!r.method){requests.get(r.id)?.(r.result);requests.delete(r.id);return;} if(r.id===undefined)return;
 handle(r).then(result=>send({id:r.id,result}),e=>send({id:r.id,error:{code:-32603,message:String(e)}}));
});
`;

const CLAUDE = String.raw`#!/usr/bin/env node
import { createInterface } from 'node:readline';
import { randomUUID } from 'node:crypto';
import { spawn } from 'node:child_process';
const origin='CONTROL_ORIGIN';
if(process.argv.includes('--version')){console.log('2.1.329 (Claude Code)');process.exit(0);}
if(process.argv.includes('auth')){console.log(JSON.stringify({loggedIn:true,authMethod:'api_key',apiProvider:'firstParty'}));process.exit(0);}
const argv=(name)=>{const equal=process.argv.find(a=>a.startsWith(name+'='));if(equal)return equal.slice(name.length+1);const i=process.argv.indexOf(name);return i<0?undefined:process.argv[i+1];};
const sessionId=argv('--session-id')??argv('--resume')??randomUUID();
let model=argv('--model')??'claude-haiku-5-5';
const usage={input_tokens:1,output_tokens:1,cache_creation_input_tokens:0,cache_read_input_tokens:0};
const send=x=>process.stdout.write(JSON.stringify({...x,session_id:sessionId,uuid:randomUUID()})+'\n');
const control=async(event,data={})=>(await fetch(origin+'/'+event,{method:'POST',body:JSON.stringify(data)})).json();
const tasks=new Map();
const roster=()=>send({type:'system',subtype:'background_tasks_changed',tasks:[...tasks.values()]});
const init=()=>send({type:'system',subtype:'init',apiKeySource:'none',claude_code_version:'2.1.329',cwd:process.cwd(),tools:['Bash'],mcp_servers:[],model,permissionMode:'bypassPermissions',slash_commands:[],output_style:'default',skills:[],plugins:[],agents:[]});
const assistant=content=>send({type:'assistant',message:{model,id:'msg_'+randomUUID(),type:'message',role:'assistant',content,stop_reason:null,stop_sequence:null,usage},parent_tool_use_id:null});
const answer=text=>{assistant([{type:'text',text}]);send({type:'result',subtype:'success',is_error:false,duration_ms:1,duration_api_ms:1,num_turns:1,result:text,stop_reason:'end_turn',total_cost_usd:0,usage,modelUsage:{},permission_denials:[]});};
async function prompt(text){
 init();
 const child=/PROOF_CHILD:(\w+)/.exec(text);
 if(child){
  const caseName=child[1];
  if(caseName==='repeat')for(const phase of ['repeat','changed']){
   const taskId=randomUUID(),toolId='toolu_'+randomUUID();
   assistant([{type:'tool_use',id:toolId,name:'Bash',input:{command:'inspect sample',description:'Background inspection ('+phase+')',run_in_background:true}}]);
   const task={task_id:taskId,task_type:'local_bash',description:'Background inspection ('+phase+')',tool_use_id:toolId};tasks.set(taskId,task);
   send({type:'system',subtype:'task_started',...task,is_backgrounded:true});roster();
   send({type:'user',message:{role:'user',content:[{type:'tool_result',tool_use_id:toolId,content:'Command is running in background with task ID '+taskId,is_error:false}]},parent_tool_use_id:null,tool_use_result:{stdout:'',stderr:'',interrupted:false,backgroundTaskId:taskId}});
   const command=spawn(process.execPath,['-e',"fetch(process.argv[1],{method:'POST'}).then(r=>r.text()).then(()=>console.log('Inspection finished.'))",origin+'/background/'+phase],{stdio:'ignore'});
   process.on('exit',()=>command.kill());
   command.on('exit',async()=>{
    tasks.delete(taskId);roster();
    send({type:'system',subtype:'task_notification',task_id:taskId,tool_use_id:toolId,status:'completed',output_file:'inspection-output.txt',summary:'Background inspection finished.'});
    init();answer(phase==='repeat'?'Inspection complete: sample is clean.':'Inspection complete: sample needs repair.');
    await control('selfstarted',{phase,sessionId});
   });
  }
  await control('child',{caseName,sessionId});answer('Inspection complete: sample is clean.');
 }else{
  const state=await control('prompt',{sessionId,text});
  answer(state.changed?'Inspection complete: sample needs repair.':'Inspection complete: sample is clean.');
  await control('answered',{sessionId});
 }
}
createInterface({input:process.stdin}).on('line',line=>{
 const m=JSON.parse(line);
 if(m.type==='control_request'){
  const r=m.request??{};let response={};
  if(r.subtype==='initialize')response={commands:[],output_style:'default',available_output_styles:['default'],models:[],account:{email:'scenario@example.invalid',subscriptionType:'api',tokenSource:'api'}};
  if(r.subtype==='mcp_set_servers')response={added:Object.keys(r.servers??{}),removed:[],errors:{}};
  if(r.subtype==='set_model')model=r.model??model;
  if(r.subtype==='background_tasks')response={tasks:[...tasks.values()]};
  send({type:'control_response',response:{subtype:'success',request_id:m.request_id,response}});
 }else if(m.type==='user'){
  const c=m.message?.content;const text=typeof c==='string'?c:(c??[]).map(x=>x.text??'').join('\n');
  prompt(text).catch(e=>{send({type:'result',subtype:'error_during_execution',is_error:true,errors:[String(e)],duration_ms:1,duration_api_ms:0,num_turns:1,total_cost_usd:0,usage,permission_denials:[]});});
 }
});
`;

test(
  "Delegated results are delivered once and changed or requested follow-ups retain context",
  WEB,
  async ({ t3, app, screen, browser }) => {
    await browser.setViewport({ width: 1600, height: 1000 });
    const sessions = new Map<string, any>();
    const events: any[] = [];
    const holds = new Map<string, () => void>();
    const childGates = new Map<string, () => void>();
    const pending = new Map<string, Array<(x: any) => void>>();
    const finishBackground = new Map<string, () => void>();
    let activeCase = "repeat";
    let deliveryMode = "normal";
    let changed = false;
    let parentNumber = 0;
    const waitEvent = (kind: string, predicate = (x: any) => true): Promise<any> => {
      const existing = events.find((e) => e.kind === kind && !e.used && predicate(e));
      if (existing) {
        existing.used = true;
        return Promise.resolve(existing);
      }
      return new Promise((resolve) => {
        const key = kind;
        const arr = pending.get(key) ?? [];
        arr.push((x) => {
          if (predicate(x)) {
            x.used = true;
            resolve(x);
            return true;
          }
          return false;
        });
        pending.set(key, arr);
      });
    };
    const emit = (kind: string, data: any) => {
      const e = { kind, ...data };
      events.push(e);
      console.log(
        "FIXTURE_EVENT " +
          kind +
          " " +
          JSON.stringify({
            caseName: data.caseName,
            sessionId: data.sessionId,
            child: data.child,
            number: data.number,
          }),
      );
      const queue = pending.get(kind) ?? [];
      const index = queue.findIndex((fn) => fn(e));
      if (index >= 0) queue.splice(index, 1);
    };
    const server = http.createServer(async (req, res) => {
      let body = "";
      for await (const chunk of req) body += chunk;
      const data = JSON.parse(body || "{}");
      const kind = req.url!.slice(1);
      const reply = (x = {}) => {
        if (!res.headersSent)
          res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(x));
      };
      if (kind.startsWith("background/")) {
        finishBackground.set(kind.split("/")[1], () => reply());
      } else if (kind === "child") {
        sessions.set(data.sessionId, { child: true, caseName: data.caseName });
        emit(kind, data);
        childGates.set(data.caseName, () => reply());
      } else if (kind === "hold") {
        holds.set(data.sessionId, () => reply());
        emit(kind, data);
      } else if (kind === "prompt") {
        const child = sessions.get(data.sessionId)?.child ?? false;
        if (!child) sessions.set(data.sessionId, { child: false });
        const userRequest =
          /<user_request>([\s\S]*?)<\/user_request>/.exec(data.text)?.[1] ?? data.text;
        const delivery = !child && userRequest.trim().startsWith("Delegated task ");
        const number = child ? 0 : delivery ? ++parentNumber : parentNumber;
        emit(kind, { ...data, child, number, delivery });
        reply({
          child,
          number,
          changed,
          resume: !child && !delivery,
          before: delivery && deliveryMode === "before",
          after: delivery && deliveryMode === "after",
        });
      } else {
        emit(kind, data);
        reply();
      }
    });
    await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
    const port = (server.address() as any).port;
    const project = await t3.project("delegation-proof", {
      "proof-agent.mjs": AGENT,
      "background-agent.mjs": CLAUDE.replace("CONTROL_ORIGIN", `http://127.0.0.1:${port}`),
    });
    await fs.chmod(path.join(project, "background-agent.mjs"), 0o755);
    const rpc = async (name: string, args: any) =>
      runPromise(
        Effect.gen(function* () {
          const c = yield* rpcClient(T3_HOME, app.baseUrl ?? "");
          return yield* (c as any)[name](args);
        }).pipe(Effect.scoped),
      );
    const dispatch = (command: any) =>
      rpc("orchestration.dispatchCommand", { commandId: randomUUID(), ...command });
    const projection = (threadId: string) => rpc("orchestration.getThreadProjection", { threadId });
    const cli = makeState(T3_HOME).cli;
    const settle = async (threadId: string) => {
      for (let n = 0; n < 200; n++) {
        const p: any = await projection(threadId);
        if (
          !p.runs.some((r: any) =>
            ["running", "starting", "preparing", "queued"].includes(r.status),
          )
        )
          return p;
        await new Promise((r) => setTimeout(r, 100));
      }
      throw Error("Thread did not settle");
    };
    const waitRuns = async (threadId: string, count: number) => {
      for (let n = 0; n < 500; n++) {
        const p: any = await projection(threadId);
        if (
          p.runs.length >= count &&
          p.runs.every((r: any) => ["completed", "failed", "cancelled"].includes(r.status))
        )
          return p;
        await new Promise((r) => setTimeout(r, 100));
      }
      throw Error("Follow-up did not finish");
    };
    const send = async (threadId: string, text: string, extra = {}) =>
      dispatch({
        type: "message.dispatch",
        createdBy: "user",
        creationSource: "web",
        threadId,
        messageId: randomUUID(),
        text,
        attachments: [],
        dispatchMode: { type: "start_immediately" },
        ...extra,
      });
    const screenshot = async (label: string) => {
      await screen.getByRole("textbox").first().waitFor();
      await screen.getByText("Syncing messages...", { exact: true }).waitFor({ state: "hidden" });
      await app.screenshot(label);
    };
    try {
      await rpc("server.updateSettings", {
        patch: {},
        providerInstanceMutation: {
          operation: "upsert",
          instanceId: "proof-replay",
          instance: {
            driver: "acpRegistry",
            displayName: "Proof replay",
            enabled: true,
            config: {
              source: "local",
              commandPath: process.execPath,
              commandArgs: [path.join(project, "proof-agent.mjs"), `http://127.0.0.1:${port}`],
            },
          },
        },
      });
      await rpc("server.updateSettings", {
        patch: {},
        providerInstanceMutation: {
          operation: "upsert",
          instanceId: "proof-background",
          instance: {
            driver: "claudeAgent",
            displayName: "Background replay",
            enabled: true,
            config: { binaryPath: path.join(project, "background-agent.mjs") },
          },
        },
      });
      const start = async (caseName: string) => {
        activeCase = caseName;
        parentNumber = 0;
        deliveryMode = "normal";
        const started = await runPromise(
          cli([
            "thread",
            "start",
            project,
            "PROOF_PARENT:" + caseName,
            "--title",
            "Delegation " + caseName,
            "--provider",
            "proof-replay",
            "--model",
            "default",
            "--json",
          ]),
        );
        const { threadId } = JSON.parse(started.stdout);
        await waitEvent("delegated", (e) => e.caseName === caseName);
        const ch = await waitEvent("child", (e) => e.caseName === caseName);
        await settle(threadId);
        await t3.open({ threadId });
        return { threadId, childSessionId: ch.sessionId };
      };
      const initial = await start("repeat");
      childGates.get("repeat")!();
      await waitEvent("answered", (e) => !sessions.get(e.sessionId)?.child);
      await settle(initial.threadId);
      let p: any = await projection(initial.threadId);
      const task = p.subagents.find((x: any) => x.childThreadId);
      const childId = task.childThreadId;
      await screenshot("original-result");
      // The child reports its native completion only after the real subprocess exits.
      finishBackground.get("repeat")!();
      await waitEvent("selfstarted", (e) => e.phase === "repeat");
      await waitRuns(childId, 2);
      await settle(initial.threadId);
      await screenshot("unchanged-followup-parent");
      const repeatP: any = await projection(initial.threadId);
      const repeatDeliveries = parentNumber;
      changed = true;
      finishBackground.get("changed")!();
      await waitEvent("selfstarted", (e) => e.phase === "changed");
      await waitRuns(childId, 3);
      await waitEvent("answered", (e) => !sessions.get(e.sessionId)?.child);
      await settle(initial.threadId);
      await screenshot("changed-followup-context");
      p = await projection(initial.threadId);
      const promptText = events.filter((e) => e.kind === "prompt" && !e.child).at(-1)?.text ?? "";
      const changedWake = promptText
        .slice(promptText.indexOf("Delegated task "))
        .split(/<\/user_request>|<runtime_info>|\n\n\[T3/)[0]
        .trim();
      const beforeRequested = parentNumber;
      await send(childId, "Please repeat the current result.");
      await waitEvent("answered", (e) => sessions.get(e.sessionId)?.child);
      await waitEvent("answered", (e) => !sessions.get(e.sessionId)?.child);
      await settle(initial.threadId);
      await screenshot("requested-identical-result");
      p = await projection(initial.threadId);
      const requestedWakes = parentNumber - beforeRequested;
      // Restart with an answered delivery still active, then without any provider output.
      const results: any = { repeatDeliveries, changedWake, requestedWakes };
      for (const mode of ["after", "before"]) {
        await app.restart();
        const current = await start(mode);
        deliveryMode = mode;
        childGates.get(mode)!();
        const held = await waitEvent("hold");
        await t3.open(current);
        await screenshot(mode + "-restart-before");
        await app.open(`http://127.0.0.1:${port}/restart-wait`);
        const oldRuntime = await fs.readFile(
          path.join(T3_HOME, "userdata/server-runtime.json"),
          "utf8",
        );
        // The app's own dev watcher performs a graceful full server restart.
        const source = path.join(APP_DIR, "apps/server/src/bin.ts");
        const now = new Date();
        await fs.utimes(source, now, now);
        deliveryMode = "normal";
        for (let n = 0; n < 300; n++) {
          await new Promise((r) => setTimeout(r, 100));
          try {
            const runtime = await fs.readFile(
              path.join(T3_HOME, "userdata/server-runtime.json"),
              "utf8",
            );
            if (runtime !== oldRuntime) break;
          } catch {}
        }
        await app.restart();
        await settle(current.threadId);
        await t3.open(current);
        await screenshot(mode + "-restart-after");
        const post: any = await projection(current.threadId);
        results[mode] = parentNumber;
      }
      await screenshot("final-proof-state");
      console.log("PROOF_OBSERVATIONS " + JSON.stringify(results));
      expect(
        results,
        "One original wake, follow-up context, requested identical wake, answered delivery not replayed, unanswered delivery retried",
      ).toEqual({
        repeatDeliveries: 1,
        changedWake: expect.stringContaining(
          "a follow-up of task " + task.id + " after the child ran again",
        ),
        requestedWakes: 1,
        after: 1,
        before: 2,
      });
    } finally {
      for (const release of finishBackground.values()) release();
      for (const release of holds.values()) release();
      for (const release of childGates.values()) release();
      server.close();
      server.closeAllConnections();
    }
  },
);
