Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,166 @@
#!/usr/bin/env node
// The original Task's primary control reads its typed owner; only explicit launch
// submits the original Todo, and recovery observes the same native operation.
// Synthetic HTTP replies isolate the browser contract; owning-backend qualification
// remains a separate packaged journey.
import assert from "node:assert/strict";
import {dirname, resolve} from "node:path";
import {fileURLToPath} from "node:url";
import {cleanupBrowserSmoke, launchBrowser, loadPlaywright, startViteDashboardServer, waitForHttp} from "../../../../examples/dashboard-browser-smoke-support.mjs";

const dashboardDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const port = Number(process.env.LOOPX_MANAGED_TASK_TEST_PORT ?? 5371);
const origin = `http://127.0.0.1:${port}`;
const server = await startViteDashboardServer({dashboardDir, port});
const storageKey = `loopx-managed-task:${JSON.stringify(["cart-repair", "codex", "original-session"])}`;
const session = {session_id: "original-session", goal_id: "cart-repair", goal_instance_id: null,
managed_agent_id: "codex", channel_id: "agent.codex", session_mode: "managed_runtime"};
const ready = {todo_id: "original-cart-task", state: "ready", source: "goal-creation",
canonical_done: false, observation: {check_count: 6, pinned_file_count: 1, basis_sha256: "confirmed-check-source"}};
const unbound = {todo_id: "original-cart-task", state: "unbound", source: null, canonical_done: false};
const native = (operationId, status = "queued") => ({session_id: session.session_id, turn_id: "original-native-turn",
client_turn_id: `managed.${operationId}`, status, origin: "native_loopx", loopx_execution: true,
loopx_request: {operation: "native_turn", todo_id: ready.todo_id,
actor: {goal_id: session.goal_id, agent_id: "codex", session_id: session.session_id}}});
let browser;
async function probe(initial = {}) {
const page = await browser.newPage();
await page.clock.install();
await page.addInitScript(({key, attempt}) => {
localStorage.setItem("loopx-pw-locale", "en");
if (attempt !== undefined && sessionStorage.getItem(key) === null) sessionStorage.setItem(key, attempt);
}, {key: storageKey, attempt: initial.attempt});
const state = {task: ready, turn: null, available: true, loseAck: false, sessions: [session], ...initial};
const reads = [], writes = [], errors = [];
page.on("pageerror", error => errors.push(error.message));
await page.route("**/api/**", async route => {
const request = route.request(), url = new URL(request.url());
if (url.pathname === "/api/chat/sessions") return route.fulfill({json: {ok: true,
schema_version: "loopx_chat_session_list_v1", goal_id: session.goal_id, managed_agent_id: "codex",
goal_instance_id: null, sessions: state.sessions}});
assert.equal(url.pathname, "/api/chat/sessions/original-session/native-turn", "No coordinator/settings/Task/session creation endpoint");
if (request.method() === "GET") {
reads.push(Object.fromEntries(url.searchParams));
assert.equal(url.searchParams.get("original_task"), "true");
assert.equal(url.searchParams.get("agent_id"), "codex");
assert.equal(url.searchParams.has("todo_id"), false, "Task selection belongs to Core");
return route.fulfill({json: {ok: true, session_id: session.session_id, managed_agent_id: "codex",
registered_agents: ["codex"], available: state.available, task: state.task, turn: state.turn}});
}
const body = request.postDataJSON(); writes.push(body);
assert.deepEqual(Object.keys(body).sort(), ["agent_id", "operation_id", "todo_id"]);
assert.equal(body.agent_id, "codex"); assert.equal(body.todo_id, ready.todo_id);
state.turn = native(body.operation_id);
if (state.loseAck) return route.abort("failed");
return route.fulfill({status: 202, json: {ok: true, session_id: session.session_id, turn: state.turn, created: true}});
});
const firstRead = initial.attempt === "{malformed" ? null : page.waitForResponse(row => row.url().includes("native-turn"));
await page.goto(origin + "/smoke/managed-task-entry-smoke.html");
if (firstRead) await firstRead;
await page.waitForFunction(() => document.querySelector('output[aria-label="History observations"]'));
const section = page.getByRole("region", {name: "Current Task", exact: true});
const button = section.locator("button.goal-loopx-primary");
const poll = async () => {
const response = page.waitForResponse(row => new URL(row.url()).pathname.endsWith("/native-turn") && row.request().method() === "GET");
await page.clock.fastForward(5100); await response;
await page.clock.runFor(30);
};
return {page, state, reads, writes, errors, section, button, poll,
async finish() {assert.deepEqual(errors, []); await page.close();}};
}
try {
await waitForHttp(origin + "/smoke/managed-task-entry-smoke.html");
browser = await launchBrowser(loadPlaywright().chromium);
{
const p = await probe({task: unbound, available: false});
assert.equal(await p.section.count(), 0, "Unconfirmed checks expose no launch control");
await p.page.clock.fastForward(16000); await p.page.clock.runFor(30);
assert.equal(p.reads.length, 1, "An unconfigured default Goal has one initial native read and no empty background queries");
assert.deepEqual(p.writes, []); await p.finish();
}
{
const p = await probe(); await p.button.waitFor();
assert.equal(await p.button.isDisabled(), false, "A ready definition permits repair despite a failed baseline");
await p.page.clock.fastForward(16000); await p.page.clock.runFor(30);
assert.equal(p.reads.length, 1, "A ready idle Task also waits for an explicit operation");
p.state.task = unbound; p.state.available = false;
await p.button.click();
await p.page.waitForFunction(() => document.querySelector("button.goal-loopx-primary")?.disabled);
assert.deepEqual(p.writes, [], "A stale ready viewport cannot launch against changed current checks");
await p.finish();
}
{
const p = await probe({loseAck: true}); await p.button.waitFor(); await p.button.click();
await p.page.waitForFunction(() => document.querySelector(".goal-loopx-mode-status")?.textContent.includes("waiting to run"));
assert.equal(p.writes.length, 1); const operation = p.writes[0].operation_id;
assert.match(operation, /^task\./); assert.equal(await p.button.isDisabled(), true);
assert.equal(await p.section.locator('[data-active="true"]').count(), 0, "Queued ACK recovery does not imply running");
await p.page.reload(); await p.button.waitFor();
assert.equal(await p.button.isDisabled(), true); assert.equal(p.writes.length, 1);
assert.equal(p.reads.at(-1).operation_id, operation, "Reload reads the retained operation");
await p.page.evaluate(() => {
Object.defineProperty(document, "hidden", {configurable: true, value: true});
document.dispatchEvent(new Event("visibilitychange"));
});
const hiddenReads = p.reads.length;
await p.page.clock.fastForward(16000); await p.page.clock.runFor(30);
assert.equal(p.reads.length, hiddenReads, "Hidden pending Tasks do not poll");
const returned = p.page.waitForResponse(row => row.url().includes("native-turn"));
await p.page.evaluate(() => {
Object.defineProperty(document, "hidden", {configurable: true, value: false});
document.dispatchEvent(new Event("visibilitychange"));
});
await returned;
p.state.turn = native(operation, "running"); await p.poll();
assert.equal(await p.section.locator('[data-active="true"]').count(), 1);
p.state.turn = native(operation, "failed"); await p.poll();
assert.equal(await p.button.isDisabled(), false); assert.equal(p.writes.length, 1, "Failure never launches automatically");
const terminalReads = p.reads.length;
await p.page.clock.fastForward(16000); await p.page.clock.runFor(30);
assert.equal(p.reads.length, terminalReads, "Known terminal Turns stop readback polling");
await p.button.click();
await p.page.waitForFunction(() => document.querySelector(".goal-loopx-mode-status")?.textContent.includes("waiting to run"));
assert.equal(p.writes.length, 2); assert.notEqual(p.writes[1].operation_id, operation, "Explicit retry owns a fresh operation after a confirmed terminal Turn");
assert.ok(Number(await p.page.getByLabel("History observations").textContent()) >= 3);
await p.finish();
}
for (const mutation of ["operation", "agent", "goal", "session", "todo", "turn-id", "missing-turn", "ordinary-turn"]) {
const saved = {operationId: "retained-request", todoId: ready.todo_id, turnId: "original-native-turn", status: "running"};
const turn = native(saved.operationId, "failed");
if (mutation === "operation") turn.client_turn_id = "managed.unrelated-request";
if (mutation === "agent") turn.loopx_request.actor.agent_id = "other-agent";
if (mutation === "goal") turn.loopx_request.actor.goal_id = "other-goal";
if (mutation === "session") turn.session_id = "other-session";
if (mutation === "todo") turn.loopx_request.todo_id = "other-task";
if (mutation === "turn-id") turn.turn_id = "different-turn";
if (mutation === "ordinary-turn") turn.loopx_execution = false;
const p = await probe({attempt: JSON.stringify(saved), turn: mutation === "missing-turn" ? null : turn});
await p.section.getByRole("alert").waitFor();
assert.equal(await p.button.textContent(), "Refresh"); await p.button.click();
await p.poll(); assert.deepEqual(p.writes, [], `${mutation}: unverifiable recovery only rereads`);
assert.equal(await p.section.locator('[data-active="true"]').count(), 0); await p.finish();
}
{
const p = await probe(); await p.button.waitFor();
await p.page.evaluate(key => sessionStorage.setItem(key, "{malformed"), storageKey);
await p.button.click(); await p.section.getByRole("alert").waitFor();
assert.deepEqual(p.writes, [], "Storage corruption immediately before launch also holds the request");
await p.finish();
}
{
const p = await probe({attempt: "{malformed"}); await p.section.getByRole("alert").waitFor();
await p.button.click(); await p.page.clock.fastForward(5100);
assert.deepEqual(p.writes, []); assert.equal(p.reads.length, 0, "Unreadable saved operation is held without inventing another request");
await p.finish();
}
{
const p = await probe({attempt: JSON.stringify({operationId: "old-failed", todoId: ready.todo_id, status: "running"}), turn: native("old-failed", "failed")});
await p.button.waitFor(); assert.equal(await p.button.isDisabled(), false, "A saved running label cannot override fresh terminal readback");
assert.equal(await p.section.locator('[data-active="true"]').count(), 0);
await p.page.evaluate(key => sessionStorage.setItem(key, "[]"), storageKey);
await p.button.click();
await p.section.getByRole("alert").waitFor(); await p.button.click();
assert.deepEqual(p.writes, [], "Later storage corruption also revokes execution"); await p.finish();
}
console.log("managed-task-entry: check-readiness, original identity, explicit native launch, ACK recovery, liveness, reload, retry and malformed-storage boundaries passed");
} finally {await cleanupBrowserSmoke({browser, server, fixturePaths: []});}
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
<!doctype html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Original Task entry</title></head>
<body><div id="root"></div><script type="module" src="./managed-task-entry-smoke.tsx"></script></body></html>
16 changes: 16 additions & 0 deletions apps/presentation/dashboard/smoke/managed-task-entry-smoke.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
import {useState} from "react";
import {createRoot} from "react-dom/client";
import {GoalLoopXMode} from "../src/features/personal-workspace/goal-loopx-mode";
import {WorkspaceI18nProvider} from "../src/features/personal-workspace/i18n";

function OriginalTaskProbe() {
const [observations, setObservations] = useState(0);
const forbidden = () => {throw new Error("Managed Task entered the coordinator owner");};
return <main>
<GoalLoopXMode onPrepare={async () => {forbidden(); return "";}} onExecute={forbidden} onChange={forbidden}
managed={{target: {goalId: "cart-repair", agentId: "codex", sessionId: "original-session"},
onObserve: async () => {setObservations(value => value + 1);}}}/>
<output aria-label="History observations">{observations}</output>
</main>;
}
createRoot(document.getElementById("root")!).render(<WorkspaceI18nProvider><OriginalTaskProbe/></WorkspaceI18nProvider>);
53 changes: 53 additions & 0 deletions apps/presentation/dashboard/src/data/chat.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1697,6 +1697,59 @@ export async function steerChatTurn(sessionId: string, turnId: string, message:
return receipt;
}

const managedTaskTurnSchema = z.object({
session_id: z.string().min(1), turn_id: z.string().min(1), client_turn_id: z.string().min(1), status: z.string().min(1),
origin: z.literal("native_loopx"), loopx_execution: z.literal(true),
loopx_request: z.object({operation: z.literal("native_turn"), todo_id: z.string().min(1),
actor: z.object({goal_id: z.string().min(1), agent_id: z.string().min(1), session_id: z.string().min(1)})}),
}).passthrough();
const managedTaskEntrySchema = z.object({ok: z.literal(true), session_id: z.string().min(1),
managed_agent_id: z.string().nullable(), registered_agents: z.array(z.string()), available: z.boolean(), reason: z.string().optional(),
task: z.discriminatedUnion("state", [
z.object({todo_id: z.string().min(1), state: z.literal("ready"), source: z.string().min(1), canonical_done: z.boolean(),
observation: z.object({check_count: z.number().int().nonnegative(), pinned_file_count: z.number().int().nonnegative(),
basis_sha256: z.string().min(1)}), reason: z.string().optional()}),
z.object({todo_id: z.string().nullable(), state: z.literal("unbound"), source: z.null(), canonical_done: z.literal(false), reason: z.string().optional()}),
]), turn: managedTaskTurnSchema.nullable(),
});
export type ManagedTaskEntry = z.infer<typeof managedTaskEntrySchema>;
export type ManagedTaskTurn = z.infer<typeof managedTaskTurnSchema>;

function verifyManagedTaskTurn(turn: ManagedTaskTurn, target: ManagedConversationTarget, operationId: string, todoId?: string) {
const actor = turn.loopx_request.actor;
if (turn.session_id !== target.sessionId || turn.client_turn_id !== `managed.${operationId}`
|| actor.session_id !== target.sessionId || actor.goal_id !== target.goalId || actor.agent_id !== target.agentId
|| todoId !== undefined && turn.loopx_request.todo_id !== todoId) throw new Error("The original Task Turn identity changed.");
}

/** Read the Core-selected original Task; preparation and check adoption grant no launch. */
export async function fetchManagedTaskEntry(target: ManagedConversationTarget, options: {operationId?: string; todoId?: string; signal?: AbortSignal} = {}) {
await resolveManagedChatSession(target, options.signal);
const query = new URLSearchParams({original_task: "true", agent_id: target.agentId});
if (options.operationId !== undefined) query.set("operation_id", options.operationId);
const result = managedTaskEntrySchema.parse(await requestJson<unknown>(
`/api/chat/sessions/${encodeURIComponent(target.sessionId)}/native-turn?${query}`, {signal: options.signal}));
if (result.session_id !== target.sessionId || result.managed_agent_id !== target.agentId || !result.registered_agents.includes(target.agentId)) {
throw new Error("The original Task entry is unavailable from this Agent.");
}
if (result.turn) {
if (!options.operationId) throw new Error("The Task read returned an unrelated operation.");
verifyManagedTaskTurn(result.turn, target, options.operationId, options.todoId);
}
return result;
}

/** Only an explicit owner operation calls the existing native Task admission. */
export async function startManagedTaskTurn(target: ManagedConversationTarget, todoId: string, operationId: string, signal?: AbortSignal) {
await resolveManagedChatSession(target, signal);
const result = z.object({ok: z.literal(true), session_id: z.string(), turn: managedTaskTurnSchema, created: z.boolean()}).parse(
await requestJson<unknown>(`/api/chat/sessions/${encodeURIComponent(target.sessionId)}/native-turn`, {method: "POST", signal,
body: JSON.stringify({agent_id: target.agentId, operation_id: operationId, todo_id: todoId})}));
if (result.session_id !== target.sessionId) throw new Error("The original Task Session changed during launch.");
verifyManagedTaskTurn(result.turn, target, operationId, todoId);
return result;
}

export type LoopXModeSnapshot = {
ok: true; session_id: string; enabled: boolean; active_turn_id: string | null; conversation_busy: boolean;
settings: Partial<LoopXModeSettings> & { execution_config?: string };
Expand Down
Loading
Loading