requesterDisplayKey: string;

task: string;

taskName?: string;

agentId?: string;

cleanup: "delete" | "keep";

label?: string;

model?: string;

runId,

label: registerParams.label,

task: registerParams.task,

agentId: registerParams.agentId,

deliveryStatus:

registerParams.expectsCompletionMessage === false ? "not_applicable" : "pending",

startedAt: now,

expect(result.childSessionKey).toMatch(/^agent:task-manager:subagent:/);

});

it("registers the target agent id for cross-agent task attribution", async () => {

hoisted.configOverride = createConfigOverride({

agents: {

defaults: {

workspace: os.tmpdir(),

},

list: [

{

id: "main",

workspace: "/tmp/workspace-main",

subagents: {

allowAgents: ["worker"],

},

},

{

id: "worker",

workspace: "/tmp/workspace-worker",

},

],

},

});

const result = await spawnSubagentDirect(

{

task: "attribute worker run",

agentId: "worker",

},

{

agentSessionKey: "agent:main:main",

},

);

expect(result.status).toBe("accepted");

expect(result.childSessionKey).toMatch(/^agent:worker:subagent:/);

const registerInput = firstRegisteredSubagentRun();

expect(registerInput.childSessionKey).toBe(result.childSessionKey);

expect(registerInput.agentId).toBe("worker");

});

it("accepts a spawned run across session patching, runtime-model persistence, registry registration, and lifecycle emission", async () => {

const operations: string[] = [];

let persistedStore: Record<string, Record<string, unknown>> | undefined;

requesterDisplayKey: ownership.completionRequesterDisplayKey,

task,

taskName,

agentId: targetAgentId,

cleanup,

label: label || undefined,

model: resolvedModel,

import { statSync } from "node:fs";

import path from "node:path";

import { afterEach, describe, expect, it, vi } from "vitest";

import { executeSqliteQuerySync, getNodeSqliteKysely } from "../infra/kysely-sync.js";

import {

executeSqliteQuerySync,

executeSqliteQueryTakeFirstSync,

getNodeSqliteKysely,

} from "../infra/kysely-sync.js";

import type { DB as OpenClawStateKyselyDatabase } from "../state/openclaw-state-db.generated.js";

import {

closeOpenClawStateDatabase,

});

});

it("persists inferred child-session agent ids in sqlite task rows", async () => {

await withOpenClawTestState(

{ layout: "state-only", prefix: "openclaw-task-agent-id-" },

async () => {

const created = createTaskRecord({

runtime: "subagent",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:worker:subagent:child",

runId: "run-worker-subagent-sqlite",

task: "Inspect worker state",

status: "running",

deliveryStatus: "pending",

});

const database = openOpenClawStateDatabase();

const db = getNodeSqliteKysely<TaskRegistryTestDatabase>(database.db);

const row = executeSqliteQueryTakeFirstSync(

database.db,

db

.selectFrom("task_runs")

.select(["agent_id", "child_session_key", "owner_key"])

.where("task_id", "=", created.taskId),

);

expect(row).toEqual({

agent_id: "worker",

child_session_key: "agent:worker:subagent:child",

owner_key: "agent:main:main",

});

resetTaskRegistryForTests({ persist: false });

expect(findTaskByRunId("run-worker-subagent-sqlite")).toMatchObject({

taskId: created.taskId,

agentId: "worker",

});

},

);

});

it("persists requester origin atomically when creating sqlite tasks", async () => {

await withOpenClawTestState(

{ layout: "state-only", prefix: "openclaw-task-create-origin-" },

});

});

it("uses the child session agent for cross-agent background task attribution", async () => {

await withTaskRegistryTempDir(async (root) => {

process.env.OPENCLAW_STATE_DIR = root;

resetTaskRegistryMemoryForTest({ persist: false });

const created = createTaskRecord({

runtime: "subagent",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:worker:subagent:child",

runId: "run-worker-subagent",

task: "Inspect worker state",

status: "running",

deliveryStatus: "pending",

});

expect(created.agentId).toBe("worker");

expect(listTasksForAgentId("worker").map((task) => task.taskId)).toEqual([created.taskId]);

expect(listTasksForAgentId("main")).toEqual([]);

});

});

it("projects inspection-time orphaned tasks as lost without mutating the registry", async () => {

await withTaskRegistryTempDir(async () => {

resetTaskRegistryMemoryForTest();

function resolveTaskAgentId(params: {

explicitAgentId?: string;

childSessionKey?: string;

ownerKey: string;

requesterSessionKey: string;

}): string | undefined {

return (

normalizeOptionalString(params.explicitAgentId) ??

parseAgentSessionKey(params.childSessionKey)?.agentId ??

parseAgentSessionKey(params.ownerKey)?.agentId ??

parseAgentSessionKey(params.requesterSessionKey)?.agentId

);

});

const agentId = resolveTaskAgentId({

explicitAgentId: params.agentId,

childSessionKey: params.childSessionKey,

ownerKey,

requesterSessionKey,

});