office-core 0.1.0

package/.runtime-dist/src/project/office-view.js

@@ -0,0 +1,405 @@
+export function buildOfficeSnapshot(input) {
+    const now = input.now ?? new Date().toISOString();
+    const summary = input.project_state?.summary ?? {};
+    const roomSettings = input.project_state?.room?.settings ?? {};
+    const roomMessages = normalizeMessages(input.project_state?.room?.messages ?? []);
+    const recentEvents = normalizeEvents(input.project_state?.recent_events ?? []);
+    const tasks = input.tasks.map((task) => normalizeTask(task, input.blocker_threshold));
+    const groupedTasks = {
+        now: tasks.filter((task) => task.bucket === "now"),
+        review: tasks.filter((task) => task.bucket === "review"),
+        blocked: tasks.filter((task) => task.bucket === "blocked"),
+        ready: tasks.filter((task) => task.bucket === "ready"),
+        done: tasks.filter((task) => task.bucket === "done"),
+    };
+    const artifacts = tasks
+        .filter((task) => task.bucket === "done")
+        .map((task) => ({
+        deliverable_id: task.artifact_ids[0] ?? `deliverable:${task.task_id}`,
+        task_id: task.task_id,
+        task_title: task.title,
+        completed_at: task.updated_at,
+        completed_by: task.owner_id,
+        summary: task.completion_summary ?? task.summary_text,
+        artifact_ids: task.artifact_ids,
+        manifest_id: task.current_manifest_id,
+    }))
+        .sort((left, right) => right.completed_at.localeCompare(left.completed_at));
+    const hostCommands = input.project_state?.local_host_commands ?? {};
+    const hosts = Object.values(input.project_state?.local_hosts ?? {})
+        .map((host) => {
+        const normalizedSessions = (host.sessions ?? []).map((session) => ({
+            ...session,
+            session_id: String(session.session_id ?? ""),
+            project_id: session.project_id ? String(session.project_id) : null,
+            agent_id: String(session.agent_id ?? ""),
+            runner: String(session.runner ?? "codex"),
+            mode: String(session.mode ?? "attach"),
+            status: String(session.status ?? "running"),
+            launched_at: String(session.launched_at ?? now),
+            task_id: session.task_id ? String(session.task_id) : null,
+            note: session.note ? String(session.note) : null,
+        }));
+        const commands = (hostCommands[String(host.host_id ?? "")] ?? []).map((command) => normalizeCommand(command));
+        const queuedCommands = commands.filter((command) => command.status === "queued" || command.status === "dispatched");
+        const online = String(host.status ?? "offline") === "online" && isFreshTimestamp(String(host.last_seen_at ?? now), now, 10000);
+        const runningSessions = online ? normalizedSessions.filter((session) => session.status === "running") : [];
+        return {
+            host_id: String(host.host_id ?? ""),
+            display_name: String(host.display_name ?? host.host_id ?? "host"),
+            hostname: String(host.hostname ?? host.host_id ?? "host"),
+            status: String(host.status ?? "offline"),
+            last_seen_at: String(host.last_seen_at ?? now),
+            default_workdir: String(host.default_workdir ?? ""),
+            online,
+            available_runners: {
+                codex: Boolean(host.available_runners?.codex),
+                claude: Boolean(host.available_runners?.claude),
+            },
+            running_sessions: runningSessions,
+            queued_commands: queuedCommands,
+            recent_commands: commands.slice(-8).reverse(),
+            active_agents: Array.from(new Set(runningSessions.map((session) => session.agent_id))).sort(),
+            environment: host.environment ?? null,
+        };
+    })
+        .sort((left, right) => {
+        if (left.online !== right.online) {
+            return left.online ? -1 : 1;
+        }
+        return right.last_seen_at.localeCompare(left.last_seen_at);
+    });
+    const statusEntries = deriveStatusRail({
+        status_feed: input.project_state?.status_feed ?? {},
+        tasks,
+    });
+    const directives = roomMessages
+        .filter((message) => message.author_type === "user")
+        .slice(-5)
+        .reverse()
+        .map((message) => ({
+        message_id: message.message_id,
+        seq: message.seq,
+        text: message.text,
+        created_at: message.created_at,
+        task_id: message.task_id ?? null,
+        author_label: message.author_label,
+    }));
+    const blockers = groupedTasks.blocked;
+    const escalatedBlockers = blockers.filter((task) => task.escalated);
+    const needsHuman = uniqueTaskCards([
+        ...groupedTasks.review,
+        ...groupedTasks.blocked.filter((task) => task.escalated),
+    ]);
+    const focusTask = groupedTasks.now[0] ??
+        groupedTasks.review[0] ??
+        groupedTasks.blocked[0] ??
+        groupedTasks.ready[0] ??
+        groupedTasks.done[0] ??
+        null;
+    const headline = summary.accepted_understanding ??
+        focusTask?.accepted_understanding ??
+        directives[0]?.text ??
+        focusTask?.summary_text ??
+        (focusTask ? `Focus on ${focusTask.title}` : "No accepted project brief yet.");
+    return {
+        meta: {
+            project_id: input.project_id,
+            generated_at: now,
+            blocker_threshold: input.blocker_threshold,
+        },
+        current_project: {
+            project_id: summary.project_id ?? input.project_id,
+            name: summary.name ?? input.project_id,
+            status: summary.status ?? "active",
+            manifest_id: summary.current_manifest_id ?? null,
+            manifest_seq: summary.current_manifest_seq ?? null,
+            accepted_understanding: summary.accepted_understanding ?? null,
+            headline,
+            focus_task_id: focusTask?.task_id ?? null,
+            focus_task_title: focusTask?.title ?? null,
+            metrics: {
+                active_tasks: tasks.filter((task) => task.bucket !== "done").length,
+                in_progress: groupedTasks.now.length,
+                blocked: groupedTasks.blocked.length,
+                review: groupedTasks.review.length,
+                completed: groupedTasks.done.length,
+                deliverables: artifacts.length,
+                live_statuses: statusEntries.length,
+                online_hosts: hosts.filter((host) => host.online).length,
+                running_sessions: hosts.reduce((count, host) => count + host.running_sessions.length, 0),
+            },
+        },
+        task_board: groupedTasks,
+        status_rail: statusEntries,
+        attention: {
+            blockers,
+            escalated_blockers: escalatedBlockers,
+            review_queue: groupedTasks.review,
+            needs_human: needsHuman,
+            human_directives: directives,
+        },
+        artifacts,
+        hosts,
+        room: {
+            settings: {
+                conductor_name: String(roomSettings.conductor_name ?? "You"),
+                all_agents_listening: Boolean(roomSettings.all_agents_listening ?? true),
+            },
+            recent_messages: roomMessages.slice(-40),
+            recent_decisions: recentEvents.filter((event) => isDecisionEvent(event.type)).slice(0, 12),
+        },
+        recent_events: recentEvents.slice(0, 24),
+    };
+}
+function normalizeTask(task, blockerThreshold) {
+    const snapshot = task.snapshot ?? {};
+    const events = normalizeTaskEvents(task.events ?? []);
+    const latestBlocker = latestEventOfType(events, "blocker.raised");
+    const latestCompletion = latestEventOfType(events, "task.completed");
+    const latestProgress = latestEventOfTypes(events, [
+        "progress.reported",
+        "alignment.proposed",
+        "human.corrected",
+        "human.confirmed",
+        "handoff.accepted",
+        "claim.granted",
+        "understanding.submitted",
+    ]);
+    const taskId = String(snapshot.task_id ?? "");
+    const ownerId = stringOrNull(snapshot.claimed_by_agent_id) ??
+        stringOrNull(latestCompletion?.actor_id) ??
+        stringOrNull(latestProgress?.actor_id) ??
+        null;
+    const attemptCount = Number(snapshot.attempt_count ?? 0);
+    const blockersOpen = Number(snapshot.blockers_open ?? 0);
+    const phase = String(snapshot.phase ?? "new");
+    const completionPayload = latestCompletion?.payload ?? {};
+    const artifactIds = Array.isArray(completionPayload.artifact_ids)
+        ? completionPayload.artifact_ids.map((value) => String(value)).filter(Boolean)
+        : [];
+    return {
+        task_id: taskId,
+        title: String((snapshot.title ?? taskId) || "Untitled task"),
+        phase,
+        bucket: bucketForPhase(phase),
+        updated_at: String(snapshot.updated_at ?? task.created_at ?? new Date(0).toISOString()),
+        owner_id: ownerId,
+        owner_label: ownerId,
+        claim_expires_at: stringOrNull(snapshot.claim_expires_at),
+        accepted_understanding: stringOrNull(snapshot.accepted_understanding),
+        summary_text: summarizeTaskEvent(latestProgress),
+        blocker_text: latestBlocker ? String(latestBlocker.payload?.message ?? "Blocked") : null,
+        completion_summary: latestCompletion ? String(latestCompletion.payload?.summary ?? "Completed") : null,
+        artifact_ids: artifactIds,
+        attempt_count: attemptCount,
+        blockers_open: blockersOpen,
+        escalated: phase === "blocked_or_handoff" && attemptCount >= blockerThreshold,
+        needs_human: phase === "awaiting_human_confirmation" || (phase === "blocked_or_handoff" && attemptCount >= blockerThreshold),
+        manifest_seq: Number.isFinite(Number(snapshot.manifest_seq)) ? Number(snapshot.manifest_seq) : null,
+        task_version: Number.isFinite(Number(snapshot.task_version)) ? Number(snapshot.task_version) : null,
+        collaboration_mode: stringOrNull(snapshot.resolved_mode),
+        confirmation_required: Boolean(snapshot.confirmation_required),
+        current_manifest_id: task.current_manifest_id ? String(task.current_manifest_id) : null,
+    };
+}
+function bucketForPhase(phase) {
+    if (phase === "executing") {
+        return "now";
+    }
+    if (phase === "awaiting_human_confirmation") {
+        return "review";
+    }
+    if (phase === "blocked_or_handoff") {
+        return "blocked";
+    }
+    if (phase === "completed") {
+        return "done";
+    }
+    return "ready";
+}
+function deriveStatusRail(input) {
+    const taskById = new Map(input.tasks.map((task) => [task.task_id, task]));
+    const entries = Object.values(input.status_feed)
+        .map((entry) => ({
+        agent_id: String(entry.agent_id ?? "agent"),
+        display_name: String(entry.display_name ?? entry.agent_id ?? "agent"),
+        task_id: entry.task_id ? String(entry.task_id) : null,
+        task_title: entry.task_id ? taskById.get(String(entry.task_id))?.title ?? null : null,
+        state: String(entry.state ?? "active"),
+        summary: String(entry.summary ?? "Working"),
+        updated_at: String(entry.updated_at ?? new Date(0).toISOString()),
+        inferred: false,
+    }))
+        .sort((left, right) => right.updated_at.localeCompare(left.updated_at));
+    const seen = new Set(entries.map((entry) => `${entry.agent_id}:${entry.task_id ?? ""}`));
+    for (const task of input.tasks) {
+        if (!task.owner_id) {
+            continue;
+        }
+        const key = `${task.owner_id}:${task.task_id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        entries.push({
+            agent_id: task.owner_id,
+            display_name: task.owner_label ?? task.owner_id,
+            task_id: task.task_id,
+            task_title: task.title,
+            state: task.bucket === "blocked" ? "blocked" : task.bucket === "done" ? "done" : "active",
+            summary: task.summary_text ?? task.blocker_text ?? task.completion_summary ?? task.title,
+            updated_at: task.updated_at,
+            inferred: true,
+        });
+        seen.add(key);
+    }
+    return entries.sort((left, right) => right.updated_at.localeCompare(left.updated_at)).slice(0, 18);
+}
+function normalizeMessages(messages) {
+    return messages
+        .map((message) => ({
+        message_id: String(message.message_id ?? `msg_${crypto.randomUUID()}`),
+        seq: Number(message.seq ?? 0),
+        author_type: String(message.author_type ?? "system"),
+        author_id: String(message.author_id ?? "system"),
+        author_label: String(message.author_label ?? message.author_id ?? "system"),
+        text: String(message.text ?? ""),
+        created_at: String(message.created_at ?? new Date(0).toISOString()),
+        task_id: message.task_id ? String(message.task_id) : null,
+        host_id: message.host_id ? String(message.host_id) : null,
+        session_id: message.session_id ? String(message.session_id) : null,
+        reply_to_seq: Number.isFinite(Number(message.reply_to_seq)) ? Number(message.reply_to_seq) : null,
+        target_host_ids: normalizeStringList(message.target_host_ids),
+        target_session_ids: normalizeStringList(message.target_session_ids),
+        target_agent_ids: normalizeStringList(message.target_agent_ids),
+    }))
+        .sort((left, right) => left.seq - right.seq);
+}
+function normalizeEvents(events) {
+    return events
+        .map((event) => ({
+        ts: String(event.ts ?? new Date(0).toISOString()),
+        kind: event.kind ?? "sys",
+        actor: String(event.actor ?? "system"),
+        type: String(event.type ?? "event"),
+        detail: event.detail ? String(event.detail) : null,
+        payload: event.payload ? String(event.payload) : null,
+    }))
+        .sort((left, right) => right.ts.localeCompare(left.ts));
+}
+function normalizeTaskEvents(events) {
+    return events
+        .map((event) => ({
+        id: String(event.id ?? `evt_${crypto.randomUUID()}`),
+        event_type: String(event.event_type ?? "event"),
+        actor_type: String(event.actor_type ?? "system"),
+        actor_id: String(event.actor_id ?? "system"),
+        payload: event.payload ?? {},
+        occurred_at: String(event.occurred_at ?? new Date(0).toISOString()),
+    }))
+        .sort((left, right) => right.occurred_at.localeCompare(left.occurred_at));
+}
+function latestEventOfType(events, eventType) {
+    return events.find((event) => event.event_type === eventType) ?? null;
+}
+function latestEventOfTypes(events, eventTypes) {
+    const allowed = new Set(eventTypes);
+    return events.find((event) => allowed.has(String(event.event_type))) ?? null;
+}
+function summarizeTaskEvent(event) {
+    if (!event) {
+        return null;
+    }
+    const payload = event.payload ?? {};
+    switch (event.event_type) {
+        case "progress.reported":
+            return String(payload.summary ?? "Progress updated");
+        case "alignment.proposed":
+            return String(payload.proposal_text ?? "Alignment proposed");
+        case "human.corrected":
+            return String(payload.correction_text ?? "Human requested changes");
+        case "human.confirmed":
+            return "Human approved execution";
+        case "claim.granted":
+            return String(payload.approach_summary ?? "Execution claimed");
+        case "handoff.accepted":
+            return String(payload.reason ?? payload.context_notes ?? "Handoff requested");
+        case "understanding.submitted":
+            return String(payload.text ?? "Understanding submitted");
+        case "task.completed":
+            return String(payload.summary ?? "Completed");
+        default:
+            return null;
+    }
+}
+function normalizeCommand(command) {
+    return {
+        command_id: String(command.command_id ?? ""),
+        command_type: String(command.command_type ?? "spawn"),
+        runner: command.runner ? String(command.runner) : undefined,
+        agent_id: String(command.agent_id ?? ""),
+        mode: command.mode ? String(command.mode) : undefined,
+        effort: command.effort ? String(command.effort) : null,
+        workdir: command.workdir ? String(command.workdir) : undefined,
+        task_id: command.task_id ? String(command.task_id) : null,
+        session_id: command.session_id ? String(command.session_id) : null,
+        prompt: command.prompt ? String(command.prompt) : null,
+        target_project_id: command.target_project_id ? String(command.target_project_id) : null,
+        target_project_name: command.target_project_name ? String(command.target_project_name) : null,
+        status: String(command.status ?? "queued"),
+        created_at: String(command.created_at ?? new Date(0).toISOString()),
+        updated_at: String(command.updated_at ?? new Date(0).toISOString()),
+        result: command.result
+            ? {
+                session_id: command.result.session_id ? String(command.result.session_id) : undefined,
+                note: command.result.note ? String(command.result.note) : null,
+                error: command.result.error ? String(command.result.error) : null,
+            }
+            : undefined,
+    };
+}
+function isFreshTimestamp(value, now, maxAgeMs) {
+    const ts = Date.parse(value);
+    const nowTs = Date.parse(now);
+    if (!Number.isFinite(ts) || !Number.isFinite(nowTs)) {
+        return false;
+    }
+    return nowTs - ts <= maxAgeMs;
+}
+function normalizeStringList(values) {
+    if (!Array.isArray(values)) {
+        return null;
+    }
+    const next = values.map((value) => String(value)).filter(Boolean);
+    return next.length > 0 ? next : null;
+}
+function stringOrNull(value) {
+    if (typeof value !== "string") {
+        return value == null ? null : String(value);
+    }
+    return value.trim() ? value : null;
+}
+function isDecisionEvent(eventType) {
+    return [
+        "task.created",
+        "bundle.published",
+        "human.confirmed",
+        "human.corrected",
+        "spawn.requested",
+        "spawn.started",
+        "spawn.failed",
+        "session.removed",
+    ].includes(String(eventType ?? ""));
+}
+function uniqueTaskCards(tasks) {
+    const seen = new Set();
+    const unique = [];
+    for (const task of tasks) {
+        if (seen.has(task.task_id)) {
+            continue;
+        }
+        seen.add(task.task_id);
+        unique.push(task);
+    }
+    return unique;
+}

package/.runtime-dist/src/project/read-model.js

@@ -0,0 +1,79 @@
+import { buildOfficeSnapshot } from "./office-view.js";
+export async function fetchProjectState(stub) {
+    const stateResponse = await stub.fetch("https://do.internal/state");
+    if (!stateResponse.ok) {
+        return null;
+    }
+    return stateResponse.json();
+}
+export async function fetchProjectStatus(stub) {
+    const statusResponse = await stub.fetch("https://do.internal/status");
+    if (!statusResponse.ok) {
+        return [];
+    }
+    return statusResponse.json();
+}
+export async function fetchProjectTasks(env, stub) {
+    const taskRefsResponse = await stub.fetch("https://do.internal/tasks");
+    if (!taskRefsResponse.ok) {
+        return [];
+    }
+    const taskRefs = await taskRefsResponse.json();
+    const tasks = await Promise.all((taskRefs ?? []).map(async (task) => {
+        const taskStub = env.TASKS.get(env.TASKS.idFromName(task.task_id));
+        const response = await taskStub.fetch("https://do.internal/snapshot");
+        if (!response.ok) {
+            return null;
+        }
+        return response.json();
+    }));
+    return tasks
+        .filter((task) => Boolean(task))
+        .sort((left, right) => {
+        const leftUpdated = left?.snapshot?.updated_at ?? left?.updated_at ?? "";
+        const rightUpdated = right?.snapshot?.updated_at ?? right?.updated_at ?? "";
+        return rightUpdated.localeCompare(leftUpdated);
+    });
+}
+export function buildProjectPayload(input) {
+    const blockerThreshold = normalizeBlockerThreshold(input.env.BLOCKER_THRESHOLD);
+    const office = buildOfficeSnapshot({
+        project_id: input.project_id,
+        project_state: input.project_state,
+        tasks: input.tasks,
+        blocker_threshold: blockerThreshold,
+        now: input.now,
+    });
+    const summary = input.project_state?.summary ?? null;
+    return {
+        ...summary,
+        id: summary?.project_id ?? input.project_id,
+        name: summary?.name ?? input.project_id,
+        status: summary?.status ?? "active",
+        current_manifest_id: summary?.current_manifest_id ?? null,
+        current_manifest_seq: summary?.current_manifest_seq ?? null,
+        accepted_understanding: summary?.accepted_understanding ?? null,
+        workspace: {
+            office_name: "Current Project",
+            guild_name: "local-office",
+        },
+        active_task_count: input.tasks.filter((task) => task?.snapshot?.phase !== "completed").length,
+        tasks: input.tasks,
+        local_hosts: Object.values(input.project_state?.local_hosts ?? {}),
+        local_host_commands: input.project_state?.local_host_commands ?? {},
+        room: input.project_state?.room ?? {
+            settings: { all_agents_listening: true, conductor_name: "You" },
+            next_seq: 0,
+            messages: [],
+        },
+        events: input.project_state?.recent_events ?? [],
+        office,
+    };
+}
+export function normalizeBlockerThreshold(value) {
+    const numeric = Number(value ?? 2);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return 2;
+    }
+    return Math.max(1, Math.floor(numeric));
+}

package/.runtime-dist/src/routes/agents-bootstrap.js

@@ -0,0 +1,9 @@
+export async function handleAgentsBootstrap(request, env) {
+    const body = await request.json();
+    const id = env.AGENTS.idFromName(body.agent_id);
+    return env.AGENTS.get(id).fetch("https://do.internal/bootstrap", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}

package/.runtime-dist/src/routes/agents-descriptor.js

@@ -0,0 +1,12 @@
+import { requireSessionClaims, readBearerToken } from "../auth/session-token.js";
+export async function handleAgentsDescriptor(request, env) {
+    const result = requireSessionClaims(request);
+    if (result instanceof Response) {
+        return result;
+    }
+    const id = env.AGENTS.idFromName(result.agent_id);
+    return env.AGENTS.get(id).fetch("https://do.internal/descriptor", {
+        method: "GET",
+        headers: { authorization: `Bearer ${readBearerToken(request)}` },
+    });
+}

package/.runtime-dist/src/routes/agents-events.js

@@ -0,0 +1,17 @@
+import { requireSessionClaims, readBearerToken } from "../auth/session-token.js";
+export async function handleAgentsEvents(request, env) {
+    const result = requireSessionClaims(request);
+    if (result instanceof Response) {
+        return result;
+    }
+    const body = await request.json();
+    const id = env.AGENTS.idFromName(result.agent_id);
+    return env.AGENTS.get(id).fetch("https://do.internal/events", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${readBearerToken(request)}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}

package/.runtime-dist/src/routes/agents-heartbeat.js

@@ -0,0 +1,21 @@
+import { requireSessionClaims, readBearerToken } from "../auth/session-token.js";
+export async function handleAgentsHeartbeat(request, env) {
+    const result = requireSessionClaims(request);
+    if (result instanceof Response) {
+        return result;
+    }
+    const body = await request.json();
+    const id = env.AGENTS.idFromName(result.agent_id);
+    return env.AGENTS.get(id).fetch("https://do.internal/heartbeat", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${readBearerToken(request)}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            session_id: result.session_id,
+            session_epoch: result.session_epoch,
+            ...body,
+        }),
+    });
+}

package/.runtime-dist/src/routes/agents-task-context.js

@@ -0,0 +1,17 @@
+import { requireSessionClaims, readBearerToken } from "../auth/session-token.js";
+export async function handleAgentsTaskContext(request, env) {
+    const result = requireSessionClaims(request);
+    if (result instanceof Response) {
+        return result;
+    }
+    const body = await request.json();
+    const id = env.AGENTS.idFromName(result.agent_id);
+    return env.AGENTS.get(id).fetch("https://do.internal/task-context", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${readBearerToken(request)}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}