@rudderhq/server 0.7.2 → 0.7.4

package/dist/services/goals.js

@@ -1,15 +1,19 @@
-import { agentWakeupRequests, agents, approvals, automations, calendarEvents, costEvents, financeEvents, goalActivities, goalChangeProposals, goalFeedbackEntries, goalOwnerAssignments, goalPlans, goalResultProposals, goalStartRequests, goals, heartbeatRuns, issues, projectGoals, projects, } from "@rudderhq/db";
-import { activateGoalSchema } from "@rudderhq/shared";
-import { and, asc, desc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { agentWakeupRequests, agents, approvals, assets, authUsers, automations, calendarEvents, costEvents, financeEvents, goalActivities, goalChangeProposals, goalFeedbackEntries, goalOwnerAssignments, goalPlans, goalResultProposals, goalStartRequests, goals, heartbeatRuns, issues, organizations, projectGoals, projects, } from "@rudderhq/db";
+import { activateGoalSchema, parseLibraryEntryMentionHref, parseLibraryFileMentionHref } from "@rudderhq/shared";
+import { and, asc, desc, eq, gt, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
 import { createHash, randomUUID } from "node:crypto";
-import { conflict, forbidden, notFound, unprocessable } from "../errors.js";
+import { badRequest, conflict, forbidden, notFound, unprocessable } from "../errors.js";
+import { buildDeferredWakePayload, readDeferredWakePayload } from "./runtime-kernel/heartbeat.sessions.js";
 const DEPENDENCY_PREVIEW_LIMIT = 5;
+const GOAL_HISTORY_DEFAULT_LIMIT = 50;
+const GOAL_HISTORY_MAX_LIMIT = 100;
 const TERMINAL_RUN_STATUSES = ["succeeded", "completed", "failed", "cancelled", "timed_out"];
+const CURRENT_PROGRESS_ACTIVITY_KINDS = ["progress", "evidence", "checkpoint", "closeout"];
 const NON_INVOKABLE_AGENT_STATUSES = new Set(["terminated", "pending_approval"]);
 const GOAL_OUTCOME_PATTERNS = [
     /\b(ship|publish|launch|deliver|creat(?:e|ed|ion)|build|complet(?:e|ed|ion)|finish|deploy|release|migrate|implement|fix|resolve|remove|establish|achieve|reach|increase|reduce|decrease|grow|choose|select|decide|approve|pass|verify|maintain|keep|sustain|recommend|submit)\b/i,
     /(?:发布|上线|交付|创建|构建|完成|部署|发版|迁移|实现|修复|解决|删除|建立|达到|提升|增加|降低|减少|增长|选择|决定|批准|通过|验证|保持|维持|产出|提交)/,
-    /(?:\d+(?:\.\d+)?\s*(?:%|percent|x|倍|个|项|天|周|月|年))|(?:[$€£¥￥]\s*\d)/i,
+    /(?:(?:\d{1,3}(?:,\d{3})+|\d+(?:\.\d+)?)\s*(?:%|percent|x|[kmb]|倍|个|项|天|周|月|年))|(?:[$€£¥￥]\s*\d)/i,
 ];
 const GOAL_MODE_PATTERNS = {
     decide: /\b(choose|select|decide|recommend|approve)\b|(?:选择|决定|推荐|批准)/i,
@@ -28,7 +32,11 @@ const CAPABILITY_STOP_WORDS = new Set([
 ]);
 function hasConcreteGoalOutcome(input) {
     const combined = `${input.title.trim()} ${input.context?.trim() ?? ""}`;
-    return input.title.trim().length >= 8 && GOAL_OUTCOME_PATTERNS.some((pattern) => pattern.test(combined));
+    if (input.title.trim().length < 8)
+        return false;
+    if (GOAL_OUTCOME_PATTERNS.some((pattern) => pattern.test(combined)))
+        return true;
+    return meaningfulTokens(combined).size >= 4 || /[\p{Script=Han}]{6,}/u.test(combined);
 }
 function goalMode(input) {
     const title = input.title.trim();
@@ -98,6 +106,413 @@ export function stableGoalHash(value) {
 function stringEvidenceRefs(value) {
     return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
+function publicOrganizationHref(path, orgUrlKey) {
+    return orgUrlKey ? `/${encodeURIComponent(orgUrlKey)}${path}` : path;
+}
+function publicEvidenceItems(value, options = {}) {
+    return stringEvidenceRefs(value).map((reference, index) => {
+        const libraryFile = parseLibraryFileMentionHref(reference);
+        if (libraryFile) {
+            const name = libraryFile.filePath.split("/").filter(Boolean).at(-1);
+            return {
+                label: name ? `Library file: ${name}` : "Library file",
+                href: publicOrganizationHref(`/library?${new URLSearchParams({ path: libraryFile.filePath }).toString()}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        const libraryEntry = parseLibraryEntryMentionHref(reference);
+        if (libraryEntry) {
+            const search = new URLSearchParams({ entry: libraryEntry.entryId });
+            if (libraryEntry.path)
+                search.set("path", libraryEntry.path);
+            return {
+                label: libraryEntry.path ? `Library entry: ${libraryEntry.path.split("/").filter(Boolean).at(-1) ?? "entry"}` : "Library entry",
+                href: publicOrganizationHref(`/library?${search.toString()}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        let parsed = null;
+        try {
+            parsed = new URL(reference);
+        }
+        catch {
+            parsed = null;
+        }
+        const scheme = parsed?.protocol.replace(/:$/, "").toLowerCase() ?? "";
+        const entityId = parsed && !parsed.username && !parsed.password && !parsed.port
+            && (parsed.pathname === "" || parsed.pathname === "/")
+            && /^[a-z0-9][a-z0-9._-]*$/i.test(parsed.hostname)
+            ? parsed.hostname
+            : null;
+        if (scheme === "issue" && entityId) {
+            return {
+                label: `Issue ${index + 1}`,
+                href: publicOrganizationHref(`/issues/${encodeURIComponent(entityId)}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        if (scheme === "project" && entityId) {
+            return {
+                label: `Project ${index + 1}`,
+                href: publicOrganizationHref(`/projects/${encodeURIComponent(entityId)}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        if (scheme === "approval" && entityId) {
+            return {
+                label: `Approval ${index + 1}`,
+                href: publicOrganizationHref(`/messenger/approvals/${encodeURIComponent(entityId)}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        if (scheme === "run" && entityId && options.runAgentId) {
+            return {
+                label: `Supporting work ${index + 1}`,
+                href: publicOrganizationHref(`/agents/${encodeURIComponent(options.runAgentId)}/runs/${encodeURIComponent(entityId)}`, options.orgUrlKey),
+                external: false,
+            };
+        }
+        if (scheme === "http" || scheme === "https") {
+            return { label: `External supporting link ${index + 1}`, href: null, external: true };
+        }
+        const label = scheme === "artifact" ? "Supporting work" : scheme ? `${scheme} support` : "Supporting work";
+        return { label: `${label} ${index + 1}`, href: null, external: false };
+    });
+}
+async function organizationUrlKey(db, orgId) {
+    return db.select({ urlKey: organizations.urlKey })
+        .from(organizations)
+        .where(eq(organizations.id, orgId))
+        .then((rows) => rows[0]?.urlKey ?? null);
+}
+function goalRunAttentionReason(status) {
+    if (status === "failed")
+        return "The Owner Agent could not complete its latest action. Decide whether to retry or adjust the Goal.";
+    if (status === "cancelled" || status === "canceled")
+        return "The Owner Agent stopped its latest action. Decide whether to retry or adjust the Goal.";
+    if (status === "timed_out" || status === "timeout")
+        return "The Owner Agent's latest action timed out. Decide whether to retry or adjust the Goal.";
+    return null;
+}
+const GOAL_HISTORY_KINDS = ["activity", "feedback", "change_proposal", "result_proposal"];
+function encodeGoalHistoryCursor(item) {
+    const createdAt = item.createdAt instanceof Date ? item.createdAt.toISOString() : new Date(item.createdAt).toISOString();
+    return Buffer.from(JSON.stringify({ version: 1, createdAt, kind: item.kind, id: item.id }))
+        .toString("base64url");
+}
+function decodeGoalHistoryCursor(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+        if (parsed.version !== 1
+            || typeof parsed.createdAt !== "string"
+            || Number.isNaN(new Date(parsed.createdAt).getTime())
+            || !GOAL_HISTORY_KINDS.includes(parsed.kind)
+            || typeof parsed.id !== "string"
+            || !parsed.id) {
+            throw new Error("invalid cursor payload");
+        }
+        return parsed;
+    }
+    catch {
+        throw badRequest("Invalid Goal history cursor");
+    }
+}
+function historyCursorCondition(timestampColumn, idColumn, kind, cursor) {
+    if (!cursor)
+        return undefined;
+    const cursorDate = new Date(cursor.createdAt);
+    const kindOrder = kind.localeCompare(cursor.kind);
+    if (kindOrder > 0)
+        return or(lt(timestampColumn, cursorDate), eq(timestampColumn, cursorDate));
+    if (kindOrder < 0)
+        return lt(timestampColumn, cursorDate);
+    return or(lt(timestampColumn, cursorDate), and(eq(timestampColumn, cursorDate), gt(idColumn, cursor.id)));
+}
+function publicGoalOutcome(outcome) {
+    if (outcome === "achieved")
+        return "Goal achieved";
+    if (outcome === "not_achieved")
+        return "Goal not achieved";
+    if (outcome === "maintained")
+        return "Goal maintained";
+    if (outcome === "breached")
+        return "Goal condition breached";
+    if (outcome === "completed_with_result")
+        return "Goal completed with a measured result";
+    if (outcome === "decided")
+        return "Goal completed with a decision";
+    return "Result needs more evidence";
+}
+const INTERNAL_GOAL_LANGUAGE = [
+    [/\bgoal\s+contract\b/gi, "Goal"],
+    [/\bcontract\s+revision\b/gi, "Goal update"],
+    [/\bcontracts?\b/gi, "agreement"],
+    [/\bobjective\s+mode\b/gi, "Goal type"],
+    [/\bevaluator\b/gi, "success check"],
+    [/\bevidence\s+requirements?\b/gi, "what we need to verify"],
+    [/\bautonomy\s+envelope\b/gi, "working boundaries"],
+    [/\bhuman\s+authorit(?:y|ies)\b/gi, "decisions that need you"],
+    [/\bcontinuation\b/gi, "next step"],
+    [/\bchange\s+proposal\b/gi, "Goal update"],
+    [/\bresult\s+proposal\b/gi, "result review"],
+    [/\bchange_proposal\b/gi, "Goal update"],
+    [/\bresult_proposal\b/gi, "result review"],
+    [/\bruntime\s+evidence\b/gi, "supporting evidence"],
+    [/\brun\s+evidence\b/gi, "supporting work"],
+    [/\bpara-memory-files\b/gi, "shared notes"],
+    [/\b(?:the\s+)?[`]?shared notes[`]?\s+skill\b/gi, "shared notes"],
+    [/\bdaily[- ]note\b/gi, "notes"],
+    [/\b(?:runtime\s+)?evidence\s+(?:demonstrates?|shows?)\s+that\b/gi, "Supporting work shows that"],
+];
+export function publicGoalText(value) {
+    const mapped = INTERNAL_GOAL_LANGUAGE.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), value);
+    return mapped
+        .replace(/\b(?:goal-feedback|goal-start|goal-change-decision|goal-result-evaluation):[0-9a-f-]{8,}\b/gi, "the related update")
+        .replace(/\b(?:artifact|run|issue|project|approval|decision|measurement|library-file|library-entry):\/\/[^\s)]+/gi, "supporting work")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "the related item")
+        .replace(/\b(?:feedback|activity|proposal|request|run)\s+(?:the related item|[0-9a-f-]{8,})\b/gi, "the related update");
+}
+function publicGoalToken(value) {
+    const known = {
+        bounded_reversible_work: "bounded, reversible work",
+        external_or_irreversible_action: "external or irreversible actions",
+        external_publication: "publishing externally",
+        authority_expansion: "expanding access",
+        acceptance: "accepting the result",
+        consequentialChanges: "consequential changes",
+        externalPublication: "publishing externally",
+    };
+    return known[value] ?? value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase();
+}
+function publicGoalRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function publicGoalStrings(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+}
+function publicGoalBoundarySummary(value) {
+    const record = publicGoalRecord(value);
+    const allowed = publicGoalStrings(record.allowed).map(publicGoalToken);
+    const approvals = publicGoalStrings(record.requiresHumanApproval).map(publicGoalToken);
+    const parts = [
+        allowed.length > 0 ? `The Agent may handle ${allowed.join(", ")}.` : null,
+        approvals.length > 0 ? `You will be asked before ${approvals.join(", ")}.` : null,
+    ].filter((part) => Boolean(part));
+    return parts.length > 0 ? parts.join(" ") : null;
+}
+function publicGoalAuthoritySummary(value) {
+    const decisions = Object.entries(publicGoalRecord(value))
+        .filter(([, entry]) => entry === "board_human" || entry === true)
+        .map(([key]) => publicGoalToken(key));
+    return decisions.length > 0 ? `You decide ${decisions.join(", ")}.` : null;
+}
+function publicGoalCompletionSummary(value) {
+    const record = publicGoalRecord(value);
+    const requiresEvidence = record.terminalEvidenceRequired === true;
+    const requiresAcceptance = record.humanAcceptanceRequired === true;
+    if (requiresEvidence && requiresAcceptance)
+        return "Supporting work is shown, and you accept the result.";
+    if (requiresEvidence)
+        return "Supporting work is shown before the result is considered ready.";
+    if (requiresAcceptance)
+        return "You accept the result when it is ready.";
+    return null;
+}
+function publicGoalContractSummary(value) {
+    const record = publicGoalRecord(value);
+    const outcomeStatement = typeof record.outcomeStatement === "string" && record.outcomeStatement.trim()
+        ? publicGoalText(record.outcomeStatement)
+        : null;
+    const criteria = Array.isArray(record.criteria)
+        ? record.criteria.flatMap((criterion) => {
+            const label = publicGoalRecord(criterion).label;
+            return typeof label === "string" && label.trim() ? [{ label: publicGoalText(label) }] : [];
+        })
+        : [];
+    const targetTime = typeof record.evaluationDeadline === "string"
+        ? record.evaluationDeadline
+        : typeof record.actionDeadline === "string" ? record.actionDeadline : null;
+    return {
+        ...(outcomeStatement ? { outcomeStatement } : {}),
+        ...(criteria.length > 0 ? { criteria } : {}),
+        ...(targetTime ? { targetTime } : {}),
+        ...(publicGoalBoundarySummary(record.autonomyEnvelope)
+            ? { boundarySummary: publicGoalBoundarySummary(record.autonomyEnvelope) } : {}),
+        ...(publicGoalAuthoritySummary(record.humanAuthorities)
+            ? { approvalSummary: publicGoalAuthoritySummary(record.humanAuthorities) } : {}),
+        ...(publicGoalCompletionSummary(record.evaluationPolicy)
+            ? { completionSummary: publicGoalCompletionSummary(record.evaluationPolicy) } : {}),
+    };
+}
+export function publicGoalView(goal) {
+    const criteria = Array.isArray(goal.criteria)
+        ? goal.criteria.flatMap((criterion) => {
+            const record = publicGoalRecord(criterion);
+            const id = typeof record.id === "string" && record.id.trim() ? record.id : null;
+            const label = typeof record.label === "string" && record.label.trim()
+                ? publicGoalText(record.label)
+                : null;
+            return id && label ? [{ id, label }] : [];
+        })
+        : [];
+    const evaluation = publicGoalRecord(goal.evaluationResult);
+    return {
+        id: goal.id,
+        orgId: goal.orgId,
+        title: goal.title,
+        description: goal.description,
+        lifecycle: goal.lifecycle,
+        status: goal.status,
+        outcomeStatement: goal.outcomeStatement ? publicGoalText(goal.outcomeStatement) : goal.outcomeStatement,
+        criteria,
+        ownerAgentId: goal.ownerAgentId,
+        ownerAgentRuntimeOverrides: goal.ownerAgentRuntimeOverrides,
+        focus: goal.focus,
+        evaluationResult: typeof evaluation.outcome === "string" ? { outcome: evaluation.outcome } : null,
+        evaluationDeadline: goal.evaluationDeadline,
+        actionDeadline: goal.actionDeadline,
+        continuationSummary: goal.continuationSummary ? publicGoalText(goal.continuationSummary) : goal.continuationSummary,
+        wakeCondition: goal.wakeCondition ? publicGoalText(goal.wakeCondition) : goal.wakeCondition,
+        alignmentQuestion: goal.alignmentQuestion ? publicGoalText(goal.alignmentQuestion) : goal.alignmentQuestion,
+        closeReason: goal.closeReason,
+        createdAt: goal.createdAt,
+        updatedAt: goal.updatedAt,
+    };
+}
+export function publicGoalActivity(activity, options = {}) {
+    return {
+        id: activity.id,
+        orgId: activity.orgId,
+        goalId: activity.goalId,
+        activityKind: activity.activityKind,
+        summary: publicGoalActivitySummary(activity),
+        evidence: publicEvidenceItems(activity.evidenceRefs, {
+            ...options,
+            runAgentId: activity.submittedByAgentId,
+        }),
+        occurredAt: activity.occurredAt,
+        createdAt: activity.createdAt,
+    };
+}
+export function publicGoalDetail(input, options = {}) {
+    return {
+        ...publicGoalView(input),
+        ownerAssignment: input.ownerAssignment
+            ? {
+                agentId: input.ownerAssignment.agentId,
+                assignmentRevision: input.ownerAssignment.assignmentRevision,
+                startsAt: input.ownerAssignment.startsAt,
+                endsAt: input.ownerAssignment.endsAt,
+            }
+            : null,
+        plan: input.plan
+            ? {
+                revision: input.plan.revision,
+                summary: publicGoalText(input.plan.summary),
+            }
+            : null,
+        activities: input.activities.map((activity) => publicGoalActivity(activity, options)),
+    };
+}
+export function publicGoalPlan(plan) {
+    return {
+        id: plan.id,
+        orgId: plan.orgId,
+        goalId: plan.goalId,
+        revision: plan.revision,
+        summary: publicGoalText(plan.summary),
+        createdAt: plan.createdAt,
+        updatedAt: plan.updatedAt,
+    };
+}
+export function publicGoalOwnerAssignment(assignment) {
+    return {
+        id: assignment.id,
+        orgId: assignment.orgId,
+        goalId: assignment.goalId,
+        agentId: assignment.agentId,
+        assignmentRevision: assignment.assignmentRevision,
+        startsAt: assignment.startsAt,
+        endsAt: assignment.endsAt,
+        createdAt: assignment.createdAt,
+    };
+}
+export function publicGoalFeedback(entry) {
+    return {
+        id: entry.id,
+        orgId: entry.orgId,
+        goalId: entry.goalId,
+        actorType: entry.actorType,
+        actorId: entry.actorId,
+        body: entry.body,
+        attachments: entry.attachments.map(({ name, mimeType, size }) => ({ name, mimeType, size })),
+        feedbackKind: entry.feedbackKind,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+    };
+}
+export function publicGoalChangeProposal(proposal, options = {}) {
+    return {
+        id: proposal.id,
+        approvalId: proposal.approvalId,
+        status: proposal.status,
+        rationale: publicGoalText(proposal.rationale),
+        evidence: publicEvidenceItems(proposal.evidenceRefs, { ...options, runAgentId: proposal.proposedByAgentId }),
+        beforeSummary: publicGoalContractSummary(proposal.beforeContract),
+        afterSummary: publicGoalContractSummary(proposal.afterContract),
+    };
+}
+export function publicGoalActivitySummary(activity) {
+    if (hasTechnicalRunSummary(activity.summary))
+        return "The Agent shared an update that needs attention.";
+    const summary = publicGoalText(activity.summary);
+    if (activity.activityKind !== "closeout")
+        return summary;
+    const legacyOutcome = /^Goal evaluated as\s+(.+)$/i.exec(summary)?.[1]?.trim();
+    return legacyOutcome ? publicGoalOutcome(legacyOutcome) : summary;
+}
+export function publicGoalResultProposal(proposal, options = {}) {
+    const preflight = publicGoalRecord(proposal.preflight);
+    const candidate = publicGoalRecord(proposal.candidate);
+    const outcome = typeof preflight.outcome === "string" ? preflight.outcome : "inconclusive";
+    const resultValue = preflight.resultValue ?? candidate.resultValue;
+    const decision = typeof preflight.decision === "string"
+        ? preflight.decision
+        : typeof candidate.decision === "string" ? candidate.decision : null;
+    const criteria = Array.isArray(preflight.criteria)
+        ? preflight.criteria.flatMap((criterion) => {
+            const record = publicGoalRecord(criterion);
+            const id = typeof record.id === "string" && record.id.trim() ? record.id : null;
+            const status = typeof record.status === "string" ? record.status : "unknown";
+            if (!id)
+                return [];
+            return [{
+                    id,
+                    status,
+                    missingEvidenceCount: Array.isArray(record.missingEvidence) ? record.missingEvidence.length : 0,
+                }];
+        })
+        : [];
+    return {
+        id: proposal.id,
+        status: proposal.status,
+        outcome,
+        outcomeLabel: outcome === "completed_with_result" && resultValue !== undefined
+            ? `Completed with result: ${String(resultValue)}`
+            : outcome === "decided" && decision
+                ? `Decision reached: ${decision}`
+                : publicGoalOutcome(outcome),
+        criteria,
+        evidence: publicEvidenceItems(candidate.evidenceRefs, { ...options, runAgentId: proposal.proposedByAgentId }),
+        riskSummary: proposal.riskSummary ? publicGoalText(proposal.riskSummary) : proposal.riskSummary,
+    };
+}
 function resultSummary(run) {
     const candidates = [run.resultSummaryJson, run.resultJson];
     for (const candidate of candidates) {
@@ -109,6 +524,85 @@ function resultSummary(run) {
     }
     return run.error?.trim() || `Agent run is ${run.status}.`;
 }
+const PROVIDER_RESULT_ENVELOPE_PATTERN = /__RUDDER_RESULT_[a-z0-9-]+__/i;
+function publicProviderSummary(value) {
+    const envelope = PROVIDER_RESULT_ENVELOPE_PATTERN.exec(value);
+    if (!envelope)
+        return value;
+    const payloadText = value.slice(envelope.index + envelope[0].length).trim();
+    try {
+        const payload = JSON.parse(payloadText);
+        if (typeof payload.body === "string" && payload.body.trim())
+            return payload.body.trim();
+    }
+    catch {
+        // Keep the visible text before a malformed internal envelope.
+    }
+    return value.slice(0, envelope.index).trim() || value;
+}
+const TECHNICAL_RUN_SUMMARY_PATTERNS = [
+    /(?:failed query|stack trace|traceback|drizzlequeryerror|connection ended|node_modules|\b(?:ECONN|ENOTFOUND|ETIMEDOUT)\b)/i,
+    /(?:^|\s)(?:error|exception):/i,
+    /\bat\s+[\w./-]+:\d+(?::\d+)?/i,
+    /(?:process adapter|missing command|adapter failure)/i,
+];
+function hasTechnicalRunSummary(value) {
+    return TECHNICAL_RUN_SUMMARY_PATTERNS.some((pattern) => pattern.test(value));
+}
+export function publicRunSummary(run) {
+    const rawSummary = publicProviderSummary(resultSummary(run));
+    if (hasTechnicalRunSummary(rawSummary)) {
+        if (["queued", "pending", "running", "started"].includes(run.status)) {
+            return "The Agent is working on this Goal.";
+        }
+        if (["succeeded", "completed"].includes(run.status)) {
+            return "The Agent completed its latest action.";
+        }
+        if (run.status === "failed")
+            return "The Agent could not complete its latest action.";
+        if (["cancelled", "canceled"].includes(run.status))
+            return "The Agent stopped its latest action.";
+        if (["timed_out", "timeout"].includes(run.status))
+            return "The Agent's latest action needs attention.";
+        return "The Agent has a new update on this Goal.";
+    }
+    const internalRunPrefix = rawSummary.match(/^Agent run\s+[\w-]+\s+is\s+[^:]+(?::\s*(.+))?$/i);
+    if (internalRunPrefix) {
+        const detail = internalRunPrefix[1]?.trim();
+        if (detail && ["succeeded", "completed"].includes(run.status))
+            return publicGoalText(detail);
+        if (["queued", "pending", "running", "started"].includes(run.status))
+            return "The Agent is working on this Goal.";
+        if (["succeeded", "completed"].includes(run.status))
+            return "The Agent completed its latest action.";
+        if (run.status === "failed")
+            return "The Agent could not complete its latest action.";
+        if (["cancelled", "canceled"].includes(run.status))
+            return "The Agent stopped its latest action.";
+        if (["timed_out", "timeout"].includes(run.status))
+            return "The Agent's latest action needs attention.";
+        return "The Agent has a new update on this Goal.";
+    }
+    const summary = publicGoalText(rawSummary);
+    const detailAfterInternalPrefix = summary.match(/^Agent run\s+[\w-]+\s+is\s+[^:]+:\s*(.+)$/i)?.[1]?.trim();
+    if (detailAfterInternalPrefix)
+        return detailAfterInternalPrefix;
+    if (!/\bagent\s+run\b/i.test(summary))
+        return summary;
+    if (["queued", "pending", "running", "started"].includes(run.status)) {
+        return "The Agent is working on this Goal.";
+    }
+    if (["succeeded", "completed"].includes(run.status)) {
+        return "The Agent completed its latest action.";
+    }
+    if (run.status === "failed")
+        return "The Agent could not complete its latest action.";
+    if (["cancelled", "canceled"].includes(run.status))
+        return "The Agent stopped its latest action.";
+    if (["timed_out", "timeout"].includes(run.status))
+        return "The Agent's latest action needs attention.";
+    return "The Agent has a new update on this Goal.";
+}
 function sameHashPayload(left, right) {
     return stableGoalHash(left) === stableGoalHash(right);
 }
@@ -185,7 +679,13 @@ export function compileGoalStartPreview(input, owner) {
             packetHash: null,
             packet: null,
             review: null,
+            blockers: [{
+                    code: "outcome_required",
+                    field: "goal",
+                    message: "Describe the result or decision someone should be able to verify. Include what changes and, when useful, a measure or deadline.",
+                }],
             alignmentQuestion: "What observable result or decision should this Goal produce, and how will we know it worked?",
+            warning: null,
         };
     }
     if (!owner || owner.id !== input.ownerAgentId || NON_INVOKABLE_AGENT_STATUSES.has(owner.status)) {
@@ -194,29 +694,29 @@ export function compileGoalStartPreview(input, owner) {
             packetHash: null,
             packet: null,
             review: null,
+            blockers: [{
+                    code: "owner_required",
+                    field: "ownerAgentId",
+                    message: "Select an available Agent from this organization to own and start the Goal.",
+                }],
             alignmentQuestion: "Which available same-organization Agent should own and advance this Goal?",
+            warning: null,
         };
     }
-    if (!ownerCanAdvanceGoal(owner, input)) {
-        return {
-            valid: false,
-            packetHash: null,
-            packet: null,
-            review: null,
-            alignmentQuestion: "The assigned Agent does not appear to cover this Goal. Which better-matched Agent should own it?",
-        };
-    }
+    const warning = ownerCanAdvanceGoal(owner, input)
+        ? null
+        : "This Agent may not be the best match for this Goal. You selected this Agent, so you can still start it or choose another Agent.";
     const mode = goalMode(input);
     const context = input.context?.trim() || null;
     const success = context
-        ? `Evidence demonstrates that ${title} while satisfying: ${context}`
+        ? `We will know it worked when ${title} and this context is satisfied: ${context}`
         : mode === "decide"
             ? `A documented decision resolves: ${title}`
             : mode === "maximize"
-                ? `Measured evidence demonstrates progress toward: ${title}`
+                ? `Progress is measured toward: ${title}`
                 : mode === "maintain"
-                    ? `Evidence confirms the condition remained true: ${title}`
-                    : `An inspectable artifact demonstrates that ${title}`;
+                    ? `The condition remains true: ${title}`
+                    : `A reviewable result shows that ${title}`;
     const firstAction = mode === "decide"
         ? "Gather the decision inputs and return with a clear recommendation and tradeoffs."
         : mode === "maximize"
@@ -249,7 +749,7 @@ export function compileGoalStartPreview(input, owner) {
         initialPlan: { summary: firstAction },
         initialContinuation: {
             kind: "commitment",
-            summary: "Advance the first bounded action and report evidence or a named blocker.",
+            summary: firstAction,
         },
     });
     const packet = {
@@ -271,7 +771,9 @@ export function compileGoalStartPreview(input, owner) {
             ownerAgentId: owner.id,
             targetTime: input.targetTime,
         },
+        blockers: [],
         alignmentQuestion: null,
+        warning,
     };
 }
 export async function getGoalDependencies(db, goal) {
@@ -339,6 +841,13 @@ async function requireGoal(db, id) {
         throw notFound("Goal not found");
     return goal;
 }
+async function requireGoalForUpdate(db, id) {
+    const goal = await db.select().from(goals).where(eq(goals.id, id))
+        .for("update").then((rows) => rows[0] ?? null);
+    if (!goal)
+        throw notFound("Goal not found");
+    return goal;
+}
 function positiveOutcome(mode, outcome) {
     return (mode === "target" && outcome === "achieved")
         || (mode === "maximize" && outcome === "completed_with_result")
@@ -455,7 +964,7 @@ function assertSameResultProposalPayload(existing, input, candidateHash) {
     }
 }
 export function goalService(db) {
-    function facetFor(goal, pendingChange, readyResult) {
+    function facetFor(goal, pendingChange, readyResult, pendingWakeup = null, externalWorkFact = null) {
         if (goal.lifecycle === "closed")
             return "closed";
         if (goal.lifecycle === "draft")
@@ -464,12 +973,139 @@ export function goalService(db) {
             return "ready_for_acceptance";
         if (pendingChange)
             return "needs_attention";
+        if (pendingWakeup?.status === "deferred_goal_focus")
+            return "waiting_focus";
+        if (pendingWakeup?.status === "deferred_goal_blocked"
+            || pendingWakeup?.status === "deferred_agent_paused")
+            return "needs_attention";
+        if (goalRunAttentionReason(externalWorkFact?.runStatus))
+            return "needs_attention";
         if (goal.continuationKind === "wait")
             return "waiting_external";
         return "agent_advancing";
     }
-    async function latestExternalCheckpoint(goal) {
-        const [issueFacts, linkedProjectFacts] = await Promise.all([
+    function goalWakeupAttentionReason(wakeup) {
+        if (wakeup?.status === "deferred_agent_paused") {
+            return "The Owner Agent is paused. Resume it to continue this Goal.";
+        }
+        if (wakeup?.status !== "deferred_goal_blocked")
+            return null;
+        if (wakeup.error === "heartbeat.wakeOnDemand.disabled") {
+            return "The Owner Agent is not accepting on-demand work. Update the Agent or choose another Owner.";
+        }
+        if (wakeup.error === "agent.unavailable") {
+            return "The Owner Agent is unavailable. Make it available or choose another Owner.";
+        }
+        if (wakeup.error === "budget.blocked") {
+            return "The Owner Agent is blocked by a budget limit. Resolve the budget decision to continue.";
+        }
+        return "The Owner Agent cannot start this work yet. Resolve its blocking condition to continue.";
+    }
+    function pendingGoalWakeup(goal) {
+        return db.select({
+            status: agentWakeupRequests.status,
+            error: agentWakeupRequests.error,
+        }).from(agentWakeupRequests).where(and(eq(agentWakeupRequests.orgId, goal.orgId), sql `${agentWakeupRequests.payload} ->> 'goalId' = ${goal.id}`, inArray(agentWakeupRequests.status, [
+            "deferred_goal_focus",
+            "deferred_goal_blocked",
+            "deferred_agent_paused",
+        ]), isNull(agentWakeupRequests.runId))).orderBy(desc(agentWakeupRequests.requestedAt)).limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function ensureGoalWakeupIntent(database, goal, input) {
+        if (!goal.ownerAgentId)
+            throw conflict("Goal has no Owner Agent to wake");
+        const taskKey = `goal:${goal.id}:${input.event}:${input.eventId}`;
+        const idempotencyKey = input.event === "goal_started"
+            ? `goal-start:${input.eventId}`
+            : input.event === "goal_feedback"
+                ? `goal-feedback:${input.eventId}`
+                : `goal-change-decision:${input.eventId}:${input.decision?.decision ?? "unknown"}`;
+        const payload = {
+            event: input.event,
+            goalId: goal.id,
+            taskKey,
+            ...(input.event === "goal_started" ? { goalStartRequestId: input.eventId } : {}),
+            ...(input.feedback ? { feedbackId: input.feedback.id } : {}),
+            ...(input.decision ? { goalChangeProposalId: input.eventId, decision: input.decision.decision } : {}),
+        };
+        const contextSnapshot = {
+            goalId: goal.id,
+            taskKey,
+            goal: {
+                id: goal.id,
+                title: goal.title,
+                description: goal.description,
+                outcomeStatement: goal.outcomeStatement,
+                objectiveMode: goal.objectiveMode,
+                contractRevision: goal.contractRevision,
+                criteria: goal.criteria,
+                autonomyEnvelope: goal.autonomyEnvelope,
+                humanAuthorities: goal.humanAuthorities,
+                evaluationPolicy: goal.evaluationPolicy,
+                actionDeadline: goal.actionDeadline,
+                evaluationDeadline: goal.evaluationDeadline,
+            },
+            goalContinuation: {
+                kind: goal.continuationKind,
+                summary: goal.continuationSummary,
+                wakeCondition: goal.wakeCondition,
+            },
+            ...(input.feedback ? {
+                goalFeedback: {
+                    id: input.feedback.id,
+                    body: input.feedback.body,
+                    kind: input.feedback.kind,
+                },
+            } : {}),
+            ...(input.decision ? {
+                goalDecision: {
+                    proposalId: input.eventId,
+                    decision: input.decision.decision,
+                    note: input.decision.note,
+                    status: input.decision.status,
+                },
+            } : {}),
+        };
+        const storedPayload = buildDeferredWakePayload(payload, contextSnapshot);
+        const [inserted] = await database.insert(agentWakeupRequests).values({
+            orgId: goal.orgId,
+            agentId: goal.ownerAgentId,
+            source: "on_demand",
+            triggerDetail: "system",
+            reason: input.event,
+            payload: storedPayload,
+            status: "queued",
+            requestedByActorType: input.actor.actorType,
+            requestedByActorId: input.actor.actorId,
+            idempotencyKey,
+        }).onConflictDoNothing().returning();
+        const wakeup = inserted ?? await database.select().from(agentWakeupRequests).where(and(eq(agentWakeupRequests.orgId, goal.orgId), eq(agentWakeupRequests.agentId, goal.ownerAgentId), eq(agentWakeupRequests.idempotencyKey, idempotencyKey))).then((rows) => rows[0] ?? null);
+        if (!wakeup)
+            throw conflict("Goal Owner wakeup could not be queued");
+        if (!sameHashPayload(readDeferredWakePayload(wakeup.payload), payload)) {
+            throw conflict("Goal Owner wakeup key was reused with a different payload");
+        }
+        const requestedByActorType = wakeup.requestedByActorType === "user"
+            || wakeup.requestedByActorType === "agent"
+            || wakeup.requestedByActorType === "system"
+            ? wakeup.requestedByActorType
+            : "system";
+        return {
+            ownerAgentId: goal.ownerAgentId,
+            wakeupRequestId: wakeup.id,
+            source: "on_demand",
+            triggerDetail: "system",
+            reason: input.event,
+            payload,
+            contextSnapshot,
+            requestedByActorType,
+            requestedByActorId: wakeup.requestedByActorId,
+            idempotencyKey,
+        };
+    }
+    async function latestExternalWorkFact(goal, preferredRunId = null) {
+        const [issueFacts, linkedProjectFacts, directRunFacts] = await Promise.all([
             db.select({
                 id: issues.id,
                 identifier: issues.identifier,
@@ -485,6 +1121,16 @@ export function goalService(db) {
                 status: projects.status,
                 updatedAt: projects.updatedAt,
             }).from(projects).leftJoin(projectGoals, and(eq(projectGoals.projectId, projects.id), eq(projectGoals.orgId, goal.orgId))).where(and(eq(projects.orgId, goal.orgId), or(eq(projects.goalId, goal.id), eq(projectGoals.goalId, goal.id)))),
+            goal.ownerAgentId
+                ? db.select({
+                    id: heartbeatRuns.id,
+                    status: heartbeatRuns.status,
+                    updatedAt: heartbeatRuns.updatedAt,
+                    resultJson: heartbeatRuns.resultJson,
+                    resultSummaryJson: heartbeatRuns.resultSummaryJson,
+                    error: heartbeatRuns.error,
+                }).from(heartbeatRuns).where(and(eq(heartbeatRuns.orgId, goal.orgId), eq(heartbeatRuns.agentId, goal.ownerAgentId), sql `${heartbeatRuns.contextSnapshot} ->> 'goalId' = ${goal.id}`))
+                : Promise.resolve([]),
         ]);
         const runIds = [...new Set(issueFacts.flatMap((issue) => [issue.checkoutRunId, issue.executionRunId]).filter((id) => Boolean(id)))];
         const runFacts = runIds.length > 0
@@ -497,36 +1143,120 @@ export function goalService(db) {
                 error: heartbeatRuns.error,
             }).from(heartbeatRuns).where(and(eq(heartbeatRuns.orgId, goal.orgId), inArray(heartbeatRuns.id, runIds)))
             : [];
-        const facts = [
+        const relatedFacts = [
             ...issueFacts.map((issue) => ({
-                id: `checkpoint:issue:${issue.id}`,
-                kind: "checkpoint",
+                id: `work-status:issue:${issue.id}`,
+                kind: "work_status",
                 summary: `Issue ${issue.identifier ?? issue.title} is ${issue.status}.`,
                 occurredAt: issue.updatedAt,
                 sourceId: issue.id,
                 sourceRunId: issue.executionRunId ?? issue.checkoutRunId,
-                evidenceRefs: [`issue://${issue.id}`],
+                runStatus: null,
+                evidenceRefs: [],
             })),
             ...linkedProjectFacts.map((project) => ({
-                id: `checkpoint:project:${project.id}`,
-                kind: "checkpoint",
+                id: `work-status:project:${project.id}`,
+                kind: "work_status",
                 summary: `Project ${project.name} is ${project.status}.`,
                 occurredAt: project.updatedAt,
                 sourceId: project.id,
                 sourceRunId: null,
-                evidenceRefs: [`project://${project.id}`],
+                runStatus: null,
+                evidenceRefs: [],
             })),
             ...runFacts.map((run) => ({
-                id: `checkpoint:run:${run.id}`,
-                kind: "checkpoint",
-                summary: `Agent run ${run.id.slice(0, 8)} is ${run.status}: ${resultSummary(run)}`,
+                id: `work-status:run:${run.id}`,
+                kind: "work_status",
+                summary: publicRunSummary(run),
                 occurredAt: run.updatedAt,
                 sourceId: run.id,
                 sourceRunId: run.id,
-                evidenceRefs: [`run://${run.id}`],
+                runStatus: run.status,
+                evidenceRefs: [],
             })),
         ];
-        return facts.sort((left, right) => right.occurredAt.getTime() - left.occurredAt.getTime())[0] ?? null;
+        const directFacts = directRunFacts
+            .filter((run) => !runFacts.some((linkedRun) => linkedRun.id === run.id))
+            .map((run) => ({
+            id: `work-status:run:${run.id}`,
+            kind: "work_status",
+            summary: publicRunSummary(run),
+            occurredAt: run.updatedAt,
+            sourceId: run.id,
+            sourceRunId: run.id,
+            runStatus: run.status,
+            evidenceRefs: [],
+        }));
+        // Run facts use a public, namespaced source id while retaining the raw run id
+        // separately for evidence links and attention actions.
+        const allRunFacts = [...relatedFacts, ...directFacts].filter((fact) => fact.id.startsWith("work-status:run:"));
+        const activeRunFacts = allRunFacts.filter((fact) => fact.runStatus && !TERMINAL_RUN_STATUSES.includes(fact.runStatus));
+        if (activeRunFacts.length > 0) {
+            return activeRunFacts.sort((left, right) => {
+                const timeDelta = right.occurredAt.getTime() - left.occurredAt.getTime();
+                return timeDelta !== 0 ? timeDelta : right.id.localeCompare(left.id);
+            })[0] ?? null;
+        }
+        const terminalRunFacts = allRunFacts.filter((fact) => (fact.runStatus && TERMINAL_RUN_STATUSES.includes(fact.runStatus)));
+        if (terminalRunFacts.length > 0) {
+            const preferredTerminal = preferredRunId
+                ? terminalRunFacts.find((fact) => fact.sourceRunId === preferredRunId) ?? null
+                : null;
+            const latestTerminal = terminalRunFacts.sort((left, right) => {
+                const timeDelta = right.occurredAt.getTime() - left.occurredAt.getTime();
+                return timeDelta !== 0 ? timeDelta : right.id.localeCompare(left.id);
+            })[0] ?? null;
+            // Preserve the Run attached to the current evidence. A newer failed,
+            // cancelled, or timed-out Run still takes priority because it needs
+            // human attention; a generic successful Run must not hide the checkpoint
+            // the user is currently inspecting.
+            if (preferredTerminal) {
+                const latestNeedsAttention = latestTerminal?.runStatus === "failed"
+                    || latestTerminal?.runStatus === "cancelled"
+                    || latestTerminal?.runStatus === "canceled"
+                    || latestTerminal?.runStatus === "timed_out"
+                    || latestTerminal?.runStatus === "timeout";
+                if (!latestNeedsAttention || preferredTerminal.occurredAt >= latestTerminal.occurredAt) {
+                    return preferredTerminal;
+                }
+            }
+            return latestTerminal;
+        }
+        const preferredRun = preferredRunId
+            ? allRunFacts.find((fact) => fact.sourceRunId === preferredRunId) ?? null
+            : null;
+        if (preferredRun)
+            return preferredRun;
+        const facts = relatedFacts.length > 0 ? relatedFacts : directFacts;
+        return facts.sort((left, right) => {
+            const timeDelta = right.occurredAt.getTime() - left.occurredAt.getTime();
+            return timeDelta !== 0 ? timeDelta : right.id.localeCompare(left.id);
+        })[0] ?? null;
+    }
+    async function requireGoalRun(database, goal, runId, actorAgentId = null) {
+        const run = await database.select({
+            id: heartbeatRuns.id,
+            orgId: heartbeatRuns.orgId,
+            agentId: heartbeatRuns.agentId,
+            status: heartbeatRuns.status,
+            contextSnapshot: heartbeatRuns.contextSnapshot,
+        }).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId)).then((rows) => rows[0] ?? null);
+        if (!run || run.orgId !== goal.orgId) {
+            throw unprocessable("Goal Activity run must belong to the same organization");
+        }
+        if (actorAgentId && run.agentId !== actorAgentId) {
+            throw unprocessable("Goal Activity run must belong to the acting Agent");
+        }
+        const context = run.contextSnapshot ?? {};
+        if (context.goalId === goal.id)
+            return run;
+        const issueId = typeof context.issueId === "string" ? context.issueId : null;
+        const linkedIssue = issueId
+            ? await database.select({ goalId: issues.goalId }).from(issues).where(and(eq(issues.id, issueId), eq(issues.orgId, goal.orgId))).then((rows) => rows[0] ?? null)
+            : null;
+        if (linkedIssue?.goalId === goal.id)
+            return run;
+        throw unprocessable("Goal Activity run must be linked to this Goal");
     }
     async function recordFeedback(database, goal, input, actorUserId) {
         assertCanonicalActiveGoal(goal);
@@ -542,9 +1272,8 @@ export function goalService(db) {
             if (existing.contentHash !== contentHash) {
                 throw conflict("Goal feedback idempotency key was reused with a different payload");
             }
-            return existing;
         }
-        const [inserted] = await database.insert(goalFeedbackEntries).values({
+        const [inserted] = existing ? [] : await database.insert(goalFeedbackEntries).values({
             orgId: goal.orgId,
             goalId: goal.id,
             actorType: "user",
@@ -555,34 +1284,28 @@ export function goalService(db) {
             feedbackKind: input.feedbackKind,
             idempotencyKey: input.idempotencyKey,
         }).onConflictDoNothing().returning();
-        const feedback = inserted ?? await database.select().from(goalFeedbackEntries).where(and(eq(goalFeedbackEntries.goalId, goal.id), eq(goalFeedbackEntries.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
+        const feedback = existing ?? inserted ?? await database.select().from(goalFeedbackEntries).where(and(eq(goalFeedbackEntries.goalId, goal.id), eq(goalFeedbackEntries.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
         if (!feedback)
             throw conflict("Goal feedback could not be recorded");
         if (feedback.contentHash !== contentHash) {
             throw conflict("Goal feedback idempotency key was reused with a different payload");
         }
-        if (feedback.routedWakeupRequestId)
-            return feedback;
-        const wakeupKey = `goal-feedback:${feedback.id}`;
-        const [insertedWakeup] = await database.insert(agentWakeupRequests).values({
-            orgId: goal.orgId,
-            agentId: goal.ownerAgentId,
-            source: "goal_feedback",
-            triggerDetail: "goal_feedback",
-            reason: "Goal feedback requires Owner review",
-            payload: { goalId: goal.id, feedbackId: feedback.id },
-            status: "queued",
-            requestedByActorType: "user",
-            requestedByActorId: actorUserId,
-            idempotencyKey: wakeupKey,
-        }).onConflictDoNothing().returning();
-        const wakeup = insertedWakeup ?? await database.select().from(agentWakeupRequests).where(and(eq(agentWakeupRequests.orgId, goal.orgId), eq(agentWakeupRequests.agentId, goal.ownerAgentId), eq(agentWakeupRequests.idempotencyKey, wakeupKey))).then((rows) => rows[0] ?? null);
-        if (!wakeup)
-            throw conflict("Goal feedback Owner wakeup could not be queued");
-        return database.update(goalFeedbackEntries).set({
-            routedWakeupRequestId: wakeup.id,
-            updatedAt: new Date(),
-        }).where(and(eq(goalFeedbackEntries.id, feedback.id), eq(goalFeedbackEntries.orgId, goal.orgId))).returning().then((rows) => rows[0] ?? feedback);
+        const dispatch = await ensureGoalWakeupIntent(database, goal, {
+            event: "goal_feedback",
+            eventId: feedback.id,
+            actor: { actorType: "user", actorId: actorUserId },
+            feedback: { id: feedback.id, body: feedback.body, kind: feedback.feedbackKind },
+        });
+        if (feedback.routedWakeupRequestId && feedback.routedWakeupRequestId !== dispatch.wakeupRequestId) {
+            throw conflict("Goal feedback is linked to a different Owner wakeup");
+        }
+        const routedFeedback = feedback.routedWakeupRequestId
+            ? feedback
+            : await database.update(goalFeedbackEntries).set({
+                routedWakeupRequestId: dispatch.wakeupRequestId,
+                updatedAt: new Date(),
+            }).where(and(eq(goalFeedbackEntries.id, feedback.id), eq(goalFeedbackEntries.orgId, goal.orgId), isNull(goalFeedbackEntries.routedWakeupRequestId))).returning().then((rows) => rows[0] ?? feedback);
+        return { feedback: routedFeedback, dispatch };
     }
     async function evaluateInTransaction(database, current, input, actorAgentId) {
         assertCanonicalActiveGoal(current);
@@ -634,137 +1357,235 @@ export function goalService(db) {
             contractRevision: current.contractRevision,
             submittedByAgentId: actorAgentId,
             agentOwnerRefAtTime: current.ownerAgentId,
-            activityKind: "evidence",
-            summary: `Goal evaluated as ${evaluation.outcome}`,
+            activityKind: "closeout",
+            summary: publicGoalOutcome(evaluation.outcome),
             evidenceRefs: input.evidenceRefs,
             idempotencyKey: acceptedProposal ? `goal-result-evaluation:${acceptedProposal.id}` : null,
         }).onConflictDoNothing();
         return goal;
     }
-    async function workspaceFor(id) {
+    async function historyFor(id, options = {}) {
         const goal = await requireGoal(db, id);
-        const [ownerAssignment, plan, activities, feedback, changes, results] = await Promise.all([
-            db.select().from(goalOwnerAssignments).where(and(eq(goalOwnerAssignments.goalId, id), isNull(goalOwnerAssignments.endsAt))).then((rows) => rows[0] ?? null),
-            goal.planRevision > 0
-                ? db.select().from(goalPlans).where(and(eq(goalPlans.goalId, id), eq(goalPlans.revision, goal.planRevision))).then((rows) => rows[0] ?? null)
-                : Promise.resolve(null),
-            db.select().from(goalActivities).where(eq(goalActivities.goalId, id))
-                .orderBy(desc(goalActivities.occurredAt), desc(goalActivities.createdAt)).limit(100),
-            db.select().from(goalFeedbackEntries).where(eq(goalFeedbackEntries.goalId, id))
-                .orderBy(desc(goalFeedbackEntries.createdAt)).limit(100),
-            db.select().from(goalChangeProposals).where(eq(goalChangeProposals.goalId, id))
-                .orderBy(desc(goalChangeProposals.createdAt)).limit(100),
-            db.select().from(goalResultProposals).where(eq(goalResultProposals.goalId, id))
-                .orderBy(desc(goalResultProposals.createdAt)).limit(100),
+        const orgUrlKey = await organizationUrlKey(db, goal.orgId);
+        const cursor = decodeGoalHistoryCursor(options.cursor);
+        const limit = options.limit ?? GOAL_HISTORY_DEFAULT_LIMIT;
+        if (!Number.isInteger(limit) || limit < 1 || limit > GOAL_HISTORY_MAX_LIMIT) {
+            throw badRequest(`Goal history limit must be between 1 and ${GOAL_HISTORY_MAX_LIMIT}`);
+        }
+        const perSourceLimit = limit + 1;
+        const [activityRows, feedbackRows, changeRows, resultRows] = await Promise.all([
+            db.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), historyCursorCondition(goalActivities.occurredAt, goalActivities.id, "activity", cursor))).orderBy(desc(goalActivities.occurredAt), asc(goalActivities.id)).limit(perSourceLimit),
+            db.select().from(goalFeedbackEntries).where(and(eq(goalFeedbackEntries.goalId, id), historyCursorCondition(goalFeedbackEntries.createdAt, goalFeedbackEntries.id, "feedback", cursor))).orderBy(desc(goalFeedbackEntries.createdAt), asc(goalFeedbackEntries.id)).limit(perSourceLimit),
+            db.select().from(goalChangeProposals).where(and(eq(goalChangeProposals.goalId, id), historyCursorCondition(goalChangeProposals.createdAt, goalChangeProposals.id, "change_proposal", cursor))).orderBy(desc(goalChangeProposals.createdAt), asc(goalChangeProposals.id)).limit(perSourceLimit),
+            db.select().from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), historyCursorCondition(goalResultProposals.createdAt, goalResultProposals.id, "result_proposal", cursor))).orderBy(desc(goalResultProposals.createdAt), asc(goalResultProposals.id)).limit(perSourceLimit),
         ]);
-        const externalCheckpoint = await latestExternalCheckpoint(goal);
-        const evidenceActivity = activities.find((activity) => stringEvidenceRefs(activity.evidenceRefs).length > 0) ?? null;
-        const progressSource = [
-            evidenceActivity
-                ? {
-                    summary: evidenceActivity.summary,
-                    sourceActivityId: evidenceActivity.id,
-                    evidenceRefs: stringEvidenceRefs(evidenceActivity.evidenceRefs),
-                    occurredAt: evidenceActivity.occurredAt,
-                }
-                : null,
-            externalCheckpoint
-                ? {
-                    summary: externalCheckpoint.summary,
-                    sourceActivityId: null,
-                    evidenceRefs: externalCheckpoint.evidenceRefs,
-                    occurredAt: externalCheckpoint.occurredAt,
-                }
-                : null,
-        ].filter((value) => Boolean(value))
-            .sort((left, right) => right.occurredAt.getTime() - left.occurredAt.getTime())[0] ?? null;
-        const pendingChange = changes.find((proposal) => proposal.status === "pending") ?? null;
-        const readyResult = results.find((proposal) => proposal.status === "ready") ?? null;
-        const facet = facetFor(goal, pendingChange, readyResult);
-        const attention = readyResult
-            ? {
-                kind: "result_proposal",
-                reason: `Review the proposed Goal result: ${readyResult.preflight.outcome}`,
-                sourceId: readyResult.id,
-            }
-            : pendingChange
-                ? {
-                    kind: "change_proposal",
-                    reason: pendingChange.rationale,
-                    sourceId: pendingChange.id,
-                }
-                : goal.lifecycle === "draft" && goal.alignmentQuestion
-                    ? { kind: "alignment_question", reason: goal.alignmentQuestion, sourceId: goal.id }
-                    : null;
-        const timeline = [
-            ...activities.map((activity) => ({
-                id: activity.id,
-                kind: "activity",
-                summary: activity.summary,
-                occurredAt: activity.occurredAt,
-                sourceId: activity.id,
-                sourceRunId: activity.runRef,
-                evidenceRefs: stringEvidenceRefs(activity.evidenceRefs),
-            })),
-            ...feedback.map((entry) => ({
+        const agentIds = Array.from(new Set([
+            ...activityRows.map((row) => row.submittedByAgentId),
+            ...changeRows.map((row) => row.proposedByAgentId),
+            ...resultRows.map((row) => row.proposedByAgentId),
+        ].filter((value) => Boolean(value))));
+        const userIds = Array.from(new Set(feedbackRows.map((row) => row.actorId).filter(Boolean)));
+        const attachmentAssetIds = Array.from(new Set(feedbackRows.flatMap((row) => row.attachments).flatMap((attachment) => {
+            const match = attachment.uri.match(/^asset:\/\/([0-9a-f-]{36})$/i);
+            return match?.[1] ? [match[1]] : [];
+        })));
+        const [agentRows, userRows, assetRows] = await Promise.all([
+            agentIds.length > 0
+                ? db.select({ id: agents.id, name: agents.name }).from(agents).where(and(eq(agents.orgId, goal.orgId), inArray(agents.id, agentIds)))
+                : Promise.resolve([]),
+            userIds.length > 0
+                ? db.select({ id: authUsers.id, name: authUsers.name }).from(authUsers).where(inArray(authUsers.id, userIds))
+                : Promise.resolve([]),
+            attachmentAssetIds.length > 0
+                ? db.select({ id: assets.id }).from(assets).where(and(eq(assets.orgId, goal.orgId), inArray(assets.id, attachmentAssetIds)))
+                : Promise.resolve([]),
+        ]);
+        const agentNames = new Map(agentRows.map((row) => [row.id, row.name]));
+        const userNames = new Map(userRows.map((row) => [row.id, row.name]));
+        const validAssetIds = new Set(assetRows.map((row) => row.id));
+        const actorName = (actorType, actorId) => {
+            if (actorType === "system")
+                return "System";
+            if (actorType === "agent")
+                return actorId ? agentNames.get(actorId) ?? "Former agent" : "System";
+            return actorId ? userNames.get(actorId) ?? "Board user" : "Board user";
+        };
+        const items = [
+            ...activityRows.map((activity) => {
+                const actorType = activity.submittedByAgentId ? "agent" : "system";
+                return {
+                    id: activity.id,
+                    kind: "activity",
+                    summary: publicGoalActivitySummary(activity),
+                    createdAt: activity.occurredAt,
+                    evidence: publicEvidenceItems(activity.evidenceRefs, {
+                        orgUrlKey,
+                        runAgentId: activity.submittedByAgentId,
+                    }),
+                    actorType,
+                    actorId: activity.submittedByAgentId,
+                    actorName: actorName(actorType, activity.submittedByAgentId),
+                    attachments: [],
+                };
+            }),
+            ...feedbackRows.map((entry) => ({
                 id: entry.id,
                 kind: "feedback",
                 summary: entry.body,
-                occurredAt: entry.createdAt,
-                sourceId: entry.id,
-                actorType: entry.actorType,
+                createdAt: entry.createdAt,
+                evidence: [],
+                actorType: "user",
                 actorId: entry.actorId,
-                attachments: entry.attachments,
+                actorName: actorName("user", entry.actorId),
+                attachments: entry.attachments.map((attachment) => {
+                    const match = attachment.uri.match(/^asset:\/\/([0-9a-f-]{36})$/i);
+                    const assetId = match?.[1] ?? null;
+                    return {
+                        name: attachment.name,
+                        mimeType: attachment.mimeType ?? null,
+                        size: attachment.size ?? null,
+                        contentPath: assetId && validAssetIds.has(assetId) ? `/api/assets/${assetId}/content` : null,
+                    };
+                }),
                 feedbackKind: entry.feedbackKind,
             })),
-            ...changes.map((proposal) => ({
+            ...changeRows.map((proposal) => ({
                 id: proposal.id,
                 kind: "change_proposal",
-                summary: proposal.rationale,
-                occurredAt: proposal.createdAt,
-                sourceId: proposal.id,
+                summary: publicGoalText(proposal.rationale),
+                createdAt: proposal.createdAt,
+                evidence: publicEvidenceItems(proposal.evidenceRefs, {
+                    orgUrlKey,
+                    runAgentId: proposal.proposedByAgentId,
+                }),
+                actorType: "agent",
+                actorId: proposal.proposedByAgentId,
+                actorName: actorName("agent", proposal.proposedByAgentId),
+                attachments: [],
                 approvalId: proposal.approvalId,
                 status: proposal.status,
-                evidenceRefs: proposal.evidenceRefs,
             })),
-            ...results.map((proposal) => ({
+            ...resultRows.map((proposal) => ({
                 id: proposal.id,
                 kind: "result_proposal",
-                summary: `Result proposed as ${proposal.preflight.outcome}: ${proposal.riskSummary}`,
-                occurredAt: proposal.createdAt,
-                sourceId: proposal.id,
+                summary: publicGoalText(`${publicGoalOutcome(proposal.preflight.outcome)}. ${proposal.riskSummary}`),
+                createdAt: proposal.createdAt,
+                evidence: publicEvidenceItems(proposal.candidate.evidenceRefs, {
+                    orgUrlKey,
+                    runAgentId: proposal.proposedByAgentId,
+                }),
+                actorType: "agent",
+                actorId: proposal.proposedByAgentId,
+                actorName: actorName("agent", proposal.proposedByAgentId),
+                attachments: [],
                 status: proposal.status,
-                evidenceRefs: proposal.candidate.evidenceRefs,
             })),
-            ...(externalCheckpoint ? [externalCheckpoint] : []),
-        ].sort((left, right) => right.occurredAt.getTime() - left.occurredAt.getTime());
+        ].sort((left, right) => {
+            const timeDifference = new Date(right.createdAt).getTime() - new Date(left.createdAt).getTime();
+            if (timeDifference !== 0)
+                return timeDifference;
+            const kindDifference = left.kind.localeCompare(right.kind);
+            return kindDifference !== 0 ? kindDifference : left.id.localeCompare(right.id);
+        });
+        const pageItems = items.slice(0, limit);
+        return {
+            items: pageItems,
+            nextCursor: items.length > limit && pageItems.length > 0
+                ? encodeGoalHistoryCursor(pageItems[pageItems.length - 1])
+                : null,
+        };
+    }
+    async function workspaceFor(id) {
+        const goal = await requireGoal(db, id);
+        const orgUrlKey = await organizationUrlKey(db, goal.orgId);
+        const [historyPage, changes, results, evidenceActivity, pendingWakeup] = await Promise.all([
+            historyFor(id),
+            db.select().from(goalChangeProposals).where(and(eq(goalChangeProposals.goalId, id), eq(goalChangeProposals.status, "pending"))).orderBy(asc(goalChangeProposals.createdAt)),
+            db.select().from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), inArray(goalResultProposals.status, ["ready", "accepted"]))).orderBy(desc(goalResultProposals.createdAt)),
+            db.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), inArray(goalActivities.activityKind, [...CURRENT_PROGRESS_ACTIVITY_KINDS]), or(isNotNull(goalActivities.runRef), sql `${goalActivities.idempotencyKey} like 'goal-result-evidence:%'`), sql `jsonb_array_length(${goalActivities.evidenceRefs}) > 0`)).orderBy(desc(goalActivities.occurredAt), desc(goalActivities.createdAt)).limit(1)
+                .then((rows) => rows[0] ?? null),
+            pendingGoalWakeup(goal),
+        ]);
+        const externalWorkFact = await latestExternalWorkFact(goal, typeof evidenceActivity?.runRef === "string" ? evidenceActivity.runRef : null);
+        const acceptedResult = results.find((proposal) => proposal.status === "accepted") ?? null;
+        const progressSource = evidenceActivity
+            ? {
+                summary: acceptedResult
+                    ? publicGoalOutcome(acceptedResult.preflight.outcome)
+                    : publicGoalActivitySummary(evidenceActivity),
+                sourceActivityId: evidenceActivity.id,
+                evidence: publicEvidenceItems(evidenceActivity.evidenceRefs, {
+                    orgUrlKey,
+                    runAgentId: evidenceActivity.submittedByAgentId,
+                }),
+            }
+            : null;
+        const pendingChange = changes[0] ?? null;
+        const readyResult = results.find((proposal) => proposal.status === "ready") ?? null;
+        const runAttentionReason = goalRunAttentionReason(externalWorkFact?.runStatus);
+        const facet = facetFor(goal, pendingChange, readyResult, pendingWakeup, externalWorkFact);
+        const wakeupAttentionReason = goalWakeupAttentionReason(pendingWakeup);
+        const attention = goal.lifecycle === "closed"
+            ? null
+            : readyResult
+                ? {
+                    kind: "result_proposal",
+                    reason: "Review the proposed Goal result and decide whether it is sufficient.",
+                    sourceId: readyResult.id,
+                }
+                : pendingChange
+                    ? {
+                        kind: "change_proposal",
+                        reason: publicGoalText(pendingChange.rationale),
+                        sourceId: pendingChange.id,
+                    }
+                    : goal.lifecycle === "draft" && goal.alignmentQuestion
+                        ? { kind: "alignment_question", reason: publicGoalText(goal.alignmentQuestion), sourceId: goal.id }
+                        : wakeupAttentionReason
+                            ? { kind: "owner_blocked", reason: wakeupAttentionReason, sourceId: pendingWakeup?.status ?? null }
+                            : runAttentionReason
+                                ? { kind: "owner_blocked", reason: runAttentionReason, sourceId: externalWorkFact?.sourceRunId ?? externalWorkFact?.sourceId ?? null }
+                                : null;
+        const publicGoal = publicGoalView(goal);
         return {
-            goal: { ...goal, ownerAssignment, plan, activities },
+            goal: publicGoal,
             facet,
-            currentGoal: { summary: goal.outcomeStatement ?? goal.title, revision: goal.contractRevision },
+            currentGoal: { summary: publicGoal.outcomeStatement ?? goal.title, updatedFromEvidence: Boolean(progressSource) },
             currentProgress: progressSource
                 ? {
                     summary: progressSource.summary,
                     sourceActivityId: progressSource.sourceActivityId,
-                    evidenceRefs: progressSource.evidenceRefs,
+                    evidence: progressSource.evidence,
                 }
                 : {
                     summary: "No evidence-backed progress has been recorded yet.",
                     sourceActivityId: null,
-                    evidenceRefs: [],
+                    evidence: [],
                 },
-            agentAction: plan ? { summary: plan.summary, sourcePlanId: plan.id, sourceIds: [plan.id] } : null,
-            nextStep: goal.continuationKind && goal.continuationSummary
-                ? {
-                    kind: goal.continuationKind,
-                    summary: goal.continuationSummary,
-                    wakeCondition: goal.wakeCondition,
-                }
-                : null,
+            agentAction: readyResult
+                ? null
+                : externalWorkFact
+                    ? {
+                        summary: externalWorkFact.summary,
+                        sourceIds: [externalWorkFact.sourceId],
+                        ...(externalWorkFact.runStatus ? { status: externalWorkFact.runStatus } : {}),
+                    }
+                    : null,
+            nextStep: readyResult
+                ? { summary: "Review the proposed result above.", wakeCondition: null }
+                : pendingChange
+                    ? { summary: "Review the proposed Goal update above.", wakeCondition: null }
+                    : goal.continuationKind && goal.continuationSummary
+                        ? {
+                            summary: publicGoalText(goal.continuationSummary),
+                            wakeCondition: goal.wakeCondition ? publicGoalText(goal.wakeCondition) : null,
+                        }
+                        : null,
             attention,
-            timeline,
-            changeProposals: changes,
-            resultProposals: results,
+            timeline: historyPage.items,
+            timelineNextCursor: historyPage.nextCursor,
+            changeProposals: changes.map((proposal) => publicGoalChangeProposal(proposal, { orgUrlKey })),
+            resultProposals: results.map((proposal) => publicGoalResultProposal(proposal, { orgUrlKey })),
         };
     }
     return {
@@ -775,6 +1596,7 @@ export function goalService(db) {
         getResultProposalById: (id) => db.select().from(goalResultProposals)
             .where(eq(goalResultProposals.id, id)).then((rows) => rows[0] ?? null),
         dependencies: (goal) => getGoalDependencies(db, goal),
+        history: historyFor,
         previewStart: async (orgId, input) => {
             if (!hasConcreteGoalOutcome(input))
                 return compileGoalStartPreview(input, null);
@@ -793,7 +1615,7 @@ export function goalService(db) {
                 : null;
             return compileGoalStartPreview(input, owner);
         },
-        start: async (orgId, input) => {
+        start: async (orgId, input, actor = { actorType: "system", actorId: null }) => {
             const computedHash = stableGoalHash(input.packet);
             if (computedHash !== input.packetHash) {
                 throw conflict("Goal Start packet hash does not match the submitted packet");
@@ -812,7 +1634,12 @@ export function goalService(db) {
                 const goal = await db.select().from(goals).where(and(eq(goals.id, replay.goalId), eq(goals.orgId, orgId))).then((rows) => rows[0] ?? null);
                 if (!goal)
                     throw conflict("Completed Goal Start request has no Goal");
-                return { goal, replayed: true };
+                const dispatch = await ensureGoalWakeupIntent(db, goal, {
+                    event: "goal_started",
+                    eventId: replay.id,
+                    actor,
+                });
+                return { goal, replayed: true, dispatch };
             }
             return db.transaction(async (tx) => {
                 const database = tx;
@@ -822,8 +1649,8 @@ export function goalService(db) {
                     context: input.packet.description,
                     ownerAgentId: input.packet.ownerAgentId,
                     targetTime: input.packet.activation.evaluationDeadline ?? null,
-                })) {
-                    throw unprocessable("Goal owner capabilities no longer match the Goal");
+                }) && !input.allowCapabilityMismatch) {
+                    throw unprocessable("Goal owner capabilities no longer match the Goal; confirm the warning before starting");
                 }
                 const [insertedRequest] = await database.insert(goalStartRequests).values({
                     orgId,
@@ -844,7 +1671,12 @@ export function goalService(db) {
                     const existingGoal = await database.select().from(goals).where(and(eq(goals.id, existing.goalId), eq(goals.orgId, orgId))).then((rows) => rows[0] ?? null);
                     if (!existingGoal)
                         throw conflict("Completed Goal Start request has no Goal");
-                    return { goal: existingGoal, replayed: true };
+                    const dispatch = await ensureGoalWakeupIntent(database, existingGoal, {
+                        event: "goal_started",
+                        eventId: existing.id,
+                        actor,
+                    });
+                    return { goal: existingGoal, replayed: true, dispatch };
                 }
                 let draft;
                 if (input.draftGoalId) {
@@ -920,7 +1752,7 @@ export function goalService(db) {
                     submittedByAgentId: null,
                     agentOwnerRefAtTime: input.packet.ownerAgentId,
                     activityKind: "progress",
-                    summary: `Goal activated with initial ${activation.initialContinuation.kind}: ${activation.initialContinuation.summary}`,
+                    summary: publicGoalText(`The Agent is starting with: ${activation.initialContinuation.summary}`),
                     evidenceRefs: [],
                     idempotencyKey: `goal-start:${insertedRequest.id}`,
                 });
@@ -933,7 +1765,12 @@ export function goalService(db) {
                 }).where(and(eq(goalStartRequests.id, insertedRequest.id), eq(goalStartRequests.status, "pending"))).returning().then((rows) => rows[0] ?? null);
                 if (!completedRequest)
                     throw conflict("Goal Start request could not be completed");
-                return { goal, replayed: false };
+                const dispatch = await ensureGoalWakeupIntent(database, goal, {
+                    event: "goal_started",
+                    eventId: completedRequest.id,
+                    actor,
+                });
+                return { goal, replayed: false, dispatch };
             });
         },
         workspace: workspaceFor,
@@ -941,40 +1778,45 @@ export function goalService(db) {
             const organizationGoals = await db.select().from(goals).where(eq(goals.orgId, orgId))
                 .orderBy(asc(goals.createdAt));
             return Promise.all(organizationGoals.map(async (goal) => {
-                const [progress, externalCheckpoint, pendingChange, readyResult, owner] = await Promise.all([
-                    db.select().from(goalActivities).where(and(eq(goalActivities.goalId, goal.id), sql `jsonb_array_length(${goalActivities.evidenceRefs}) > 0`)).orderBy(desc(goalActivities.occurredAt), desc(goalActivities.createdAt)).limit(1)
+                const [progress, pendingChange, readyResult, owner, pendingWakeup, externalWorkFact] = await Promise.all([
+                    db.select().from(goalActivities).where(and(eq(goalActivities.goalId, goal.id), inArray(goalActivities.activityKind, [...CURRENT_PROGRESS_ACTIVITY_KINDS]), or(isNotNull(goalActivities.runRef), sql `${goalActivities.idempotencyKey} like 'goal-result-evidence:%'`), sql `jsonb_array_length(${goalActivities.evidenceRefs}) > 0`)).orderBy(desc(goalActivities.occurredAt), desc(goalActivities.createdAt)).limit(1)
                         .then((rows) => rows[0] ?? null),
-                    latestExternalCheckpoint(goal),
                     db.select().from(goalChangeProposals).where(and(eq(goalChangeProposals.goalId, goal.id), eq(goalChangeProposals.status, "pending"))).orderBy(asc(goalChangeProposals.createdAt)).limit(1).then((rows) => rows[0] ?? null),
                     db.select().from(goalResultProposals).where(and(eq(goalResultProposals.goalId, goal.id), eq(goalResultProposals.status, "ready"))).orderBy(asc(goalResultProposals.createdAt)).limit(1).then((rows) => rows[0] ?? null),
                     goal.ownerAgentId
                         ? db.select({ name: agents.name }).from(agents).where(and(eq(agents.id, goal.ownerAgentId), eq(agents.orgId, orgId))).then((rows) => rows[0] ?? null)
                         : Promise.resolve(null),
+                    pendingGoalWakeup(goal),
+                    latestExternalWorkFact(goal),
                 ]);
-                const currentProgress = [
-                    progress ? { summary: progress.summary, occurredAt: progress.occurredAt } : null,
-                    externalCheckpoint ? { summary: externalCheckpoint.summary, occurredAt: externalCheckpoint.occurredAt } : null,
-                ].filter((value) => Boolean(value))
-                    .sort((left, right) => right.occurredAt.getTime() - left.occurredAt.getTime())[0]?.summary
-                    ?? "No evidence-backed progress has been recorded yet.";
-                const attentionReason = readyResult
-                    ? `Review the proposed Goal result: ${readyResult.preflight.outcome}`
-                    : pendingChange?.rationale ?? (goal.lifecycle === "draft" ? goal.alignmentQuestion : null);
+                const currentProgress = progress
+                    ? publicGoalActivitySummary(progress)
+                    : "No evidence-backed progress has been recorded yet.";
+                const attentionReason = goal.lifecycle === "closed"
+                    ? null
+                    : readyResult
+                        ? `Review the proposed Goal result: ${publicGoalOutcome(readyResult.preflight.outcome)}`
+                        : pendingChange?.rationale
+                            ?? (goal.lifecycle === "draft" ? goal.alignmentQuestion : null)
+                            ?? goalWakeupAttentionReason(pendingWakeup)
+                            ?? goalRunAttentionReason(externalWorkFact?.runStatus);
                 return {
                     id: goal.id,
                     orgId: goal.orgId,
                     title: goal.title,
                     lifecycle: goal.lifecycle,
                     status: goal.status,
-                    facet: facetFor(goal, pendingChange, readyResult),
+                    facet: facetFor(goal, pendingChange, readyResult, pendingWakeup, externalWorkFact),
                     ownerAgentId: goal.ownerAgentId,
                     ownerName: owner?.name ?? null,
                     currentProgress,
                     progressSummary: currentProgress,
-                    nextAction: goal.continuationSummary,
-                    nextStepSummary: goal.continuationSummary ?? "No next step has been recorded.",
+                    nextAction: goal.continuationSummary ? publicGoalText(goal.continuationSummary) : null,
+                    nextStepSummary: goal.continuationSummary
+                        ? publicGoalText(goal.continuationSummary)
+                        : "No next step has been recorded.",
                     targetTime: goal.evaluationDeadline ?? goal.actionDeadline,
-                    attentionReason,
+                    attentionReason: attentionReason ? publicGoalText(attentionReason) : null,
                     focus: goal.focus,
                     updatedAt: goal.updatedAt,
                 };
@@ -992,23 +1834,60 @@ export function goalService(db) {
             ]);
             return { ...goal, ownerAssignment, plan, activities };
         },
-        create: async (orgId, data) => db.insert(goals).values({
-            orgId,
-            title: data.title,
-            description: data.description ?? null,
-            alignmentQuestion: data.alignmentQuestion ?? null,
-            level: "task",
-            status: "planned",
-            lifecycle: "draft",
-            parentId: null,
-            ownerAgentId: null,
-        }).returning().then((rows) => rows[0]),
+        create: async (orgId, data) => {
+            if (data.ownerAgentId)
+                await requireInvokableOwner(db, orgId, data.ownerAgentId);
+            return db.insert(goals).values({
+                orgId,
+                title: data.title,
+                description: data.description ?? null,
+                alignmentQuestion: data.alignmentQuestion ?? null,
+                evaluationDeadline: data.targetTime ?? null,
+                level: "task",
+                status: "planned",
+                lifecycle: "draft",
+                parentId: null,
+                ownerAgentId: data.ownerAgentId ?? null,
+                ownerAgentRuntimeOverrides: data.ownerAgentRuntimeOverrides ?? null,
+            }).returning().then((rows) => rows[0]);
+        },
         update: async (id, data, actorAgentId = null) => {
-            const current = await requireGoal(db, id);
-            assertGoalOwner(current, actorAgentId);
-            const { title, description, alignmentQuestion } = data;
-            return db.update(goals).set({ title, description, alignmentQuestion, updatedAt: new Date() })
-                .where(eq(goals.id, id)).returning().then((rows) => rows[0] ?? null);
+            return db.transaction(async (tx) => {
+                const database = tx;
+                const current = await requireGoalForUpdate(database, id);
+                assertGoalOwner(current, actorAgentId);
+                if (current.lifecycle === "closed") {
+                    throw conflict("Closed Goals are read-only");
+                }
+                if (current.lifecycle !== "draft" && actorAgentId) {
+                    throw forbidden("Active Goal direction changes require a human-approved Goal change proposal");
+                }
+                if ((data.ownerAgentId !== undefined || data.targetTime !== undefined) && current.lifecycle !== "draft") {
+                    throw conflict("Owner and target time can only be edited while a Goal is a Draft");
+                }
+                if (data.ownerAgentId)
+                    await requireInvokableOwner(database, current.orgId, data.ownerAgentId);
+                const { title, description, alignmentQuestion, ownerAgentId, ownerAgentRuntimeOverrides, targetTime } = data;
+                const ownerChanged = ownerAgentId !== undefined && ownerAgentId !== current.ownerAgentId;
+                const changedGoal = await database.update(goals).set({
+                    title,
+                    description,
+                    alignmentQuestion,
+                    ...(ownerAgentId !== undefined ? { ownerAgentId } : {}),
+                    ...(ownerAgentRuntimeOverrides !== undefined
+                        ? { ownerAgentRuntimeOverrides }
+                        : ownerChanged
+                            ? { ownerAgentRuntimeOverrides: null }
+                            : {}),
+                    ...(targetTime !== undefined ? { evaluationDeadline: targetTime } : {}),
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(goals.id, id), eq(goals.lifecycle, current.lifecycle)))
+                    .returning().then((rows) => rows[0] ?? null);
+                if (!changedGoal)
+                    throw conflict("Goal changed before update; reload and retry");
+                return changedGoal;
+            });
         },
         activate: async (id, input, actorAgentId = null) => {
             const current = await requireGoal(db, id);
@@ -1062,7 +1941,7 @@ export function goalService(db) {
                     submittedByAgentId: actorAgentId,
                     agentOwnerRefAtTime: input.ownerAgentId,
                     activityKind: "progress",
-                    summary: `Goal activated with initial ${input.initialContinuation.kind}: ${input.initialContinuation.summary}`,
+                    summary: publicGoalText(`The Agent is starting with: ${input.initialContinuation.summary}`),
                     evidenceRefs: [],
                 });
                 return goal;
@@ -1070,72 +1949,80 @@ export function goalService(db) {
             return result;
         },
         updatePlan: async (id, input, actorAgentId = null) => {
-            const current = await requireGoal(db, id);
-            assertCanonicalActiveGoal(current);
-            assertGoalOwner(current, actorAgentId);
-            const revision = current.planRevision + 1;
             return db.transaction(async (tx) => {
-                const [plan] = await tx.insert(goalPlans).values({
+                const database = tx;
+                const current = await requireGoalForUpdate(database, id);
+                assertCanonicalActiveGoal(current);
+                assertGoalOwner(current, actorAgentId);
+                const revision = current.planRevision + 1;
+                const [plan] = await database.insert(goalPlans).values({
                     orgId: current.orgId,
                     goalId: id,
                     revision,
                     ...input,
                     createdByAgentId: actorAgentId,
                 }).returning();
-                await tx.update(goals).set({ planRevision: revision, updatedAt: new Date() }).where(eq(goals.id, id));
+                const changedGoal = await database.update(goals).set({ planRevision: revision, updatedAt: new Date() })
+                    .where(and(eq(goals.id, id), eq(goals.lifecycle, "active"), eq(goals.planRevision, current.planRevision)))
+                    .returning().then((rows) => rows[0] ?? null);
+                if (!changedGoal)
+                    throw conflict("Goal changed before Plan update; reload and retry");
                 return plan;
             });
         },
         listActivities: (id) => db.select().from(goalActivities).where(eq(goalActivities.goalId, id))
             .orderBy(desc(goalActivities.occurredAt), desc(goalActivities.createdAt)).limit(100),
         createActivity: async (id, input, actorAgentId = null) => {
-            const current = await requireGoal(db, id);
-            assertCanonicalActiveGoal(current);
-            assertGoalOwner(current, actorAgentId);
-            if (input.activityKind === "closeout" && !input.runRef) {
-                throw unprocessable("A closeout Activity requires a Run reference");
-            }
-            if (input.runRef) {
-                const run = await db.select({ id: heartbeatRuns.id, orgId: heartbeatRuns.orgId, status: heartbeatRuns.status })
-                    .from(heartbeatRuns).where(eq(heartbeatRuns.id, input.runRef)).then((rows) => rows[0] ?? null);
-                if (!run || run.orgId !== current.orgId)
-                    throw unprocessable("Goal Activity run must belong to the same organization");
-                if (input.activityKind === "closeout" && !TERMINAL_RUN_STATUSES.includes(run.status)) {
-                    throw conflict("A closeout Activity requires a terminal Run");
+            return db.transaction(async (tx) => {
+                const database = tx;
+                const current = await requireGoalForUpdate(database, id);
+                assertCanonicalActiveGoal(current);
+                assertGoalOwner(current, actorAgentId);
+                if (actorAgentId && !input.runRef) {
+                    throw unprocessable("Goal Activity must be attributed to the acting Agent's Run");
                 }
-            }
-            const [activity] = await db.insert(goalActivities).values({
-                orgId: current.orgId,
-                goalId: id,
-                contractRevision: current.contractRevision,
-                submittedByAgentId: actorAgentId,
-                agentOwnerRefAtTime: current.ownerAgentId,
-                activityKind: input.activityKind ?? "progress",
-                commitmentRef: input.commitmentRef ?? null,
-                runRef: input.runRef ?? null,
-                summary: input.summary,
-                evidenceRefs: input.evidenceRefs,
-                idempotencyKey: input.idempotencyKey ?? null,
-                occurredAt: input.occurredAt ?? new Date(),
-            }).onConflictDoNothing().returning();
-            if (activity)
-                return activity;
-            if (input.idempotencyKey) {
-                const existingIdempotent = await db.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), eq(goalActivities.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
-                if (existingIdempotent)
-                    return existingIdempotent;
-            }
-            if (input.activityKind === "closeout" && input.runRef) {
-                const existingCloseout = await db.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), eq(goalActivities.runRef, input.runRef), eq(goalActivities.activityKind, "closeout"))).then((rows) => rows[0] ?? null);
-                if (existingCloseout)
-                    throw conflict("A closeout Activity already exists for this Run");
-            }
-            throw conflict("Goal Activity was already recorded");
+                if (input.activityKind === "closeout" && !input.runRef) {
+                    throw unprocessable("A closeout Activity requires a Run reference");
+                }
+                if (input.runRef) {
+                    const run = await requireGoalRun(database, current, input.runRef, actorAgentId);
+                    if (input.activityKind === "closeout" && !TERMINAL_RUN_STATUSES.includes(run.status)) {
+                        throw conflict("A closeout Activity requires a terminal Run");
+                    }
+                }
+                const [activity] = await database.insert(goalActivities).values({
+                    orgId: current.orgId,
+                    goalId: id,
+                    contractRevision: current.contractRevision,
+                    submittedByAgentId: actorAgentId,
+                    agentOwnerRefAtTime: current.ownerAgentId,
+                    activityKind: input.activityKind ?? "progress",
+                    commitmentRef: input.commitmentRef ?? null,
+                    runRef: input.runRef ?? null,
+                    summary: input.summary,
+                    evidenceRefs: input.evidenceRefs,
+                    idempotencyKey: input.idempotencyKey ?? null,
+                    occurredAt: input.occurredAt ?? new Date(),
+                }).onConflictDoNothing().returning();
+                if (activity)
+                    return activity;
+                if (input.idempotencyKey) {
+                    const existingIdempotent = await database.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), eq(goalActivities.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
+                    if (existingIdempotent)
+                        return existingIdempotent;
+                }
+                if (input.activityKind === "closeout" && input.runRef) {
+                    const existingCloseout = await database.select().from(goalActivities).where(and(eq(goalActivities.goalId, id), eq(goalActivities.runRef, input.runRef), eq(goalActivities.activityKind, "closeout"))).then((rows) => rows[0] ?? null);
+                    if (existingCloseout)
+                        throw conflict("A closeout Activity already exists for this Run");
+                }
+                throw conflict("Goal Activity was already recorded");
+            });
         },
         feedback: async (id, input, actorUserId) => {
             return db.transaction(async (tx) => {
                 const database = tx;
-                const current = await requireGoal(database, id);
+                const current = await requireGoalForUpdate(database, id);
                 return recordFeedback(database, current, input, actorUserId);
             });
         },
@@ -1145,7 +2032,7 @@ export function goalService(db) {
             const normalizedPatch = normalizeContractPatch(input.afterContract);
             return db.transaction(async (tx) => {
                 const database = tx;
-                const current = await requireGoal(database, id);
+                const current = await requireGoalForUpdate(database, id);
                 assertCanonicalActiveGoal(current);
                 assertGoalOwner(current, actorAgentId);
                 const existing = await database.select().from(goalChangeProposals).where(and(eq(goalChangeProposals.goalId, id), eq(goalChangeProposals.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
@@ -1154,7 +2041,7 @@ export function goalService(db) {
                     return existing;
                 }
                 if (current.contractRevision !== input.expectedContractRevision) {
-                    throw conflict("Goal Contract revision changed before proposal creation", {
+                    throw conflict("Goal changed before the proposed update could be created", {
                         expectedContractRevision: input.expectedContractRevision,
                         currentContractRevision: current.contractRevision,
                     });
@@ -1172,7 +2059,7 @@ export function goalService(db) {
                     evaluationPolicy: mergedContract.evaluationPolicy,
                     actionDeadline: mergedContract.actionDeadline,
                     evaluationDeadline: mergedContract.evaluationDeadline,
-                    initialPlan: { summary: "Validate the proposed Contract revision" },
+                    initialPlan: { summary: "Validate the proposed Goal update" },
                     initialContinuation: {
                         kind: current.continuationKind,
                         summary: current.continuationSummary,
@@ -1187,18 +2074,24 @@ export function goalService(db) {
                     if (!linkedApproval
                         || linkedApproval.orgId !== current.orgId
                         || linkedApproval.type !== "goal_change"
-                        || linkedApproval.status !== "pending") {
+                        || linkedApproval.status !== "pending"
+                        || linkedApproval.requestedByAgentId !== actorAgentId) {
                         throw unprocessable("Goal change approval must be pending and belong to the same organization");
                     }
-                    await database.update(approvals).set({
+                    const boundApproval = await database.update(approvals).set({
                         payload: {
-                            ...linkedApproval.payload,
                             goalId: id,
                             proposalId,
                             expectedContractRevision: current.contractRevision,
+                            beforeContract,
+                            afterContract: normalizedPatch,
+                            rationale: input.rationale,
+                            evidenceRefs: input.evidenceRefs,
                         },
                         updatedAt: new Date(),
-                    }).where(eq(approvals.id, approvalId));
+                    }).where(and(eq(approvals.id, approvalId), eq(approvals.status, "pending"))).returning().then((rows) => rows[0] ?? null);
+                    if (!boundApproval)
+                        throw conflict("Goal change approval changed before it could be linked");
                 }
                 else {
                     await database.insert(approvals).values({
@@ -1249,21 +2142,28 @@ export function goalService(db) {
                     .where(eq(goalChangeProposals.id, proposalId)).then((rows) => rows[0] ?? null);
                 if (!proposal)
                     throw notFound("Goal change proposal not found");
-                if (input.decision === "approve" && proposal.status === "applied")
-                    return { proposal, stale: false };
-                if (input.decision === "reject" && proposal.status === "rejected")
-                    return { proposal, stale: false };
+                const approval = await database.select().from(approvals).where(and(eq(approvals.id, proposal.approvalId), eq(approvals.orgId, proposal.orgId))).then((rows) => rows[0] ?? null);
+                if (!approval || approval.type !== "goal_change") {
+                    throw unprocessable("Goal change proposal approval is invalid");
+                }
+                if ((input.decision === "approve" && proposal.status === "applied")
+                    || (input.decision === "reject" && proposal.status === "rejected")) {
+                    const current = await requireGoalForUpdate(database, proposal.goalId);
+                    const dispatch = await ensureGoalWakeupIntent(database, current, {
+                        event: "goal_change_decided",
+                        eventId: proposal.id,
+                        actor: { actorType: "user", actorId: actorUserId },
+                        decision: { decision: input.decision, note: approval.decisionNote, status: proposal.status },
+                    });
+                    return { proposal, stale: false, dispatch };
+                }
                 if (proposal.status !== "pending") {
                     throw conflict(`Goal change proposal is already ${proposal.status}`);
                 }
-                const current = await requireGoal(database, proposal.goalId);
+                const current = await requireGoalForUpdate(database, proposal.goalId);
                 assertCanonicalActiveGoal(current);
                 if (current.orgId !== proposal.orgId)
                     throw unprocessable("Goal change proposal organization mismatch");
-                const approval = await database.select().from(approvals).where(and(eq(approvals.id, proposal.approvalId), eq(approvals.orgId, proposal.orgId))).then((rows) => rows[0] ?? null);
-                if (!approval || approval.type !== "goal_change") {
-                    throw unprocessable("Goal change proposal approval is invalid");
-                }
                 if (input.decision === "reject") {
                     const now = new Date();
                     await database.update(approvals).set({
@@ -1290,13 +2190,21 @@ export function goalService(db) {
                         evidenceRefs: proposal.evidenceRefs,
                         idempotencyKey: `goal-change:${proposal.id}:rejected`,
                     }).onConflictDoNothing();
-                    return { proposal: rejected, stale: false };
+                    const dispatch = await ensureGoalWakeupIntent(database, current, {
+                        event: "goal_change_decided",
+                        eventId: proposal.id,
+                        actor: { actorType: "user", actorId: actorUserId },
+                        decision: { decision: "reject", note: input.note ?? null, status: rejected.status },
+                    });
+                    return { proposal: rejected, stale: false, dispatch };
                 }
                 if (current.contractRevision !== proposal.expectedContractRevision) {
                     const now = new Date();
                     await database.update(approvals).set({
-                        status: "approved",
-                        decisionNote: input.note ?? null,
+                        status: "cancelled",
+                        decisionNote: input.note
+                            ? `${input.note}\n\nNot applied because the Goal changed before this decision.`
+                            : "Not applied because the Goal changed before this decision.",
                         decidedByUserId: actorUserId,
                         decidedAt: now,
                         updatedAt: now,
@@ -1319,7 +2227,7 @@ export function goalService(db) {
                     evaluationPolicy: merged.evaluationPolicy,
                     actionDeadline: merged.actionDeadline,
                     evaluationDeadline: merged.evaluationDeadline,
-                    initialPlan: { summary: "Apply the approved Contract revision" },
+                    initialPlan: { summary: "Apply the approved Goal update" },
                     initialContinuation: {
                         kind: current.continuationKind,
                         summary: current.continuationSummary,
@@ -1351,7 +2259,7 @@ export function goalService(db) {
                     updatedAt: now,
                 }).where(and(eq(goals.id, current.id), eq(goals.orgId, proposal.orgId), eq(goals.lifecycle, "active"), eq(goals.contractRevision, proposal.expectedContractRevision))).returning().then((rows) => rows[0] ?? null);
                 if (!changedGoal)
-                    throw conflict("Goal Contract revision changed before proposal application");
+                    throw conflict("Goal changed before the approved update could be applied");
                 await database.insert(goalActivities).values({
                     orgId: current.orgId,
                     goalId: current.id,
@@ -1359,7 +2267,7 @@ export function goalService(db) {
                     submittedByAgentId: proposal.proposedByAgentId,
                     agentOwnerRefAtTime: current.ownerAgentId,
                     activityKind: "decision_requested",
-                    summary: `Applied Goal Contract revision ${nextRevision}: ${proposal.rationale}`,
+                    summary: `Goal updated after approval: ${proposal.rationale}`,
                     evidenceRefs: proposal.evidenceRefs,
                     idempotencyKey: `goal-change:${proposal.id}:applied`,
                 }).onConflictDoNothing();
@@ -1371,39 +2279,56 @@ export function goalService(db) {
                 }).where(and(eq(goalChangeProposals.id, proposal.id), eq(goalChangeProposals.status, "pending"))).returning().then((rows) => rows[0] ?? null);
                 if (!applied)
                     throw conflict("Goal change proposal changed before application");
-                return { proposal: applied, stale: false };
+                const dispatch = await ensureGoalWakeupIntent(database, changedGoal, {
+                    event: "goal_change_decided",
+                    eventId: proposal.id,
+                    actor: { actorType: "user", actorId: actorUserId },
+                    decision: { decision: "approve", note: input.note ?? null, status: applied.status },
+                });
+                return { proposal: applied, stale: false, dispatch };
             });
             if (result.stale) {
-                throw conflict("Goal Contract revision changed before proposal application", {
+                throw conflict("Goal changed before the approved update could be applied", {
                     expectedContractRevision: result.proposal.expectedContractRevision,
                     currentContractRevision: result.currentRevision,
                 });
             }
-            return result.proposal;
+            if (!result.dispatch)
+                throw conflict("Goal change decision could not queue the Owner continuation");
+            return { proposal: result.proposal, dispatch: result.dispatch };
         },
-        createResultProposal: async (id, input, actorAgentId) => {
+        createResultProposal: async (id, input, actorAgentId, actorRunId = null) => {
             if (!actorAgentId)
                 throw forbidden("Only the Goal Owner Agent can submit a Result Proposal");
             const candidate = evaluationCandidate(input);
             const candidateHash = stableGoalHash(candidate);
             return db.transaction(async (tx) => {
                 const database = tx;
-                const current = await requireGoal(database, id);
+                const current = await requireGoalForUpdate(database, id);
+                assertGoalOwner(current, actorAgentId);
+                if (actorRunId)
+                    await requireGoalRun(database, current, actorRunId, actorAgentId);
                 const existing = await database.select().from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), eq(goalResultProposals.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
                 if (existing) {
                     assertSameResultProposalPayload(existing, input, candidateHash);
                     return existing;
                 }
                 assertCanonicalActiveGoal(current);
-                assertGoalOwner(current, actorAgentId);
                 if (input.contractRevision !== current.contractRevision) {
-                    throw conflict("Goal Contract revision changed before Result Proposal creation", {
+                    throw conflict("Goal changed before the result could be proposed", {
                         expectedContractRevision: input.contractRevision,
                         currentContractRevision: current.contractRevision,
                     });
                 }
                 const preflight = reduceGoalEvaluation(current, candidate);
                 const status = isTerminalEvaluation(preflight.outcome) ? "ready" : "inconclusive";
+                if (status === "ready") {
+                    const readyProposal = await database.select({ id: goalResultProposals.id })
+                        .from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), eq(goalResultProposals.status, "ready"))).limit(1).then((rows) => rows[0] ?? null);
+                    if (readyProposal) {
+                        throw conflict("This Goal already has a Result Proposal ready for review");
+                    }
+                }
                 const [proposal] = await database.insert(goalResultProposals).values({
                     orgId: current.orgId,
                     goalId: current.id,
@@ -1417,6 +2342,13 @@ export function goalService(db) {
                     proposedByAgentId: actorAgentId,
                 }).onConflictDoNothing().returning();
                 const persisted = proposal ?? await database.select().from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), eq(goalResultProposals.idempotencyKey, input.idempotencyKey))).then((rows) => rows[0] ?? null);
+                if (!persisted && status === "ready") {
+                    const readyProposal = await database.select({ id: goalResultProposals.id })
+                        .from(goalResultProposals).where(and(eq(goalResultProposals.goalId, id), eq(goalResultProposals.status, "ready"))).limit(1).then((rows) => rows[0] ?? null);
+                    if (readyProposal) {
+                        throw conflict("This Goal already has a Result Proposal ready for review");
+                    }
+                }
                 if (!persisted)
                     throw conflict("Goal Result Proposal could not be recorded");
                 assertSameResultProposalPayload(persisted, input, candidateHash);
@@ -1428,12 +2360,25 @@ export function goalService(db) {
                         submittedByAgentId: actorAgentId,
                         agentOwnerRefAtTime: current.ownerAgentId,
                         activityKind: "bottleneck",
+                        runRef: actorRunId,
                         summary: inconclusiveResultSummary(preflight, input.riskSummary),
                         evidenceRefs: candidate.evidenceRefs,
                         idempotencyKey: `goal-result-inconclusive:${input.idempotencyKey}`,
                     }).onConflictDoNothing();
                     return persisted;
                 }
+                await database.insert(goalActivities).values({
+                    orgId: current.orgId,
+                    goalId: current.id,
+                    contractRevision: current.contractRevision,
+                    submittedByAgentId: actorAgentId,
+                    agentOwnerRefAtTime: current.ownerAgentId,
+                    activityKind: "evidence",
+                    runRef: actorRunId,
+                    summary: `${publicGoalOutcome(preflight.outcome)} is ready for review. ${input.riskSummary}`,
+                    evidenceRefs: candidate.evidenceRefs,
+                    idempotencyKey: `goal-result-evidence:${input.idempotencyKey}`,
+                }).onConflictDoNothing();
                 return persisted;
             });
         },
@@ -1444,7 +2389,7 @@ export function goalService(db) {
                     .where(eq(goalResultProposals.id, proposalId)).then((rows) => rows[0] ?? null);
                 if (!proposal)
                     throw notFound("Goal Result Proposal not found");
-                const current = await requireGoal(database, proposal.goalId);
+                const current = await requireGoalForUpdate(database, proposal.goalId);
                 if (current.orgId !== proposal.orgId)
                     throw unprocessable("Goal Result Proposal organization mismatch");
                 if (proposal.consumedAt) {
@@ -1458,7 +2403,7 @@ export function goalService(db) {
                 }
                 assertCanonicalActiveGoal(current);
                 if (proposal.contractRevision !== current.contractRevision) {
-                    throw conflict("Goal Contract revision changed before Result Proposal acceptance", {
+                    throw conflict("Goal changed before the result could be accepted", {
                         expectedContractRevision: proposal.contractRevision,
                         currentContractRevision: current.contractRevision,
                     });
@@ -1484,10 +2429,27 @@ export function goalService(db) {
                     const latestProposal = await database.select().from(goalResultProposals)
                         .where(eq(goalResultProposals.id, proposal.id)).then((rows) => rows[0] ?? null);
                     if (latestProposal?.consumedAt && latestProposal.acceptanceIdempotencyKey === input.idempotencyKey) {
-                        return requireGoal(database, proposal.goalId);
+                        return requireGoalForUpdate(database, proposal.goalId);
                     }
                     throw conflict("Goal Result Proposal changed before acceptance");
                 }
+                const pendingChanges = await database.select({
+                    id: goalChangeProposals.id,
+                    approvalId: goalChangeProposals.approvalId,
+                }).from(goalChangeProposals).where(and(eq(goalChangeProposals.goalId, current.id), eq(goalChangeProposals.status, "pending")));
+                if (pendingChanges.length > 0) {
+                    await database.update(goalChangeProposals).set({
+                        status: "superseded",
+                        updatedAt: now,
+                    }).where(and(eq(goalChangeProposals.goalId, current.id), eq(goalChangeProposals.status, "pending")));
+                    await database.update(approvals).set({
+                        status: "cancelled",
+                        decisionNote: "Closed because the Goal result was accepted before this proposed change was applied.",
+                        decidedByUserId: actorUserId,
+                        decidedAt: now,
+                        updatedAt: now,
+                    }).where(and(inArray(approvals.id, pendingChanges.map((change) => change.approvalId)), inArray(approvals.status, ["pending", "revision_requested"])));
+                }
                 return evaluateInTransaction(database, current, {
                     ...proposal.candidate,
                     resultProposalId: proposal.id,
@@ -1505,19 +2467,28 @@ export function goalService(db) {
                     if (proposal.rejectionFeedback !== input.feedback) {
                         throw conflict("Goal Result Proposal rejection was replayed with different feedback");
                     }
-                    return proposal;
+                    const current = await requireGoalForUpdate(database, proposal.goalId);
+                    if (current.lifecycle !== "active")
+                        return { proposal, dispatch: null };
+                    const { dispatch } = await recordFeedback(database, current, {
+                        body: input.feedback,
+                        attachments: [],
+                        feedbackKind: "ordinary",
+                        idempotencyKey: input.idempotencyKey,
+                    }, actorUserId);
+                    return { proposal, dispatch };
                 }
                 if (proposal.status !== "ready") {
                     throw conflict(`Goal Result Proposal is already ${proposal.status}`);
                 }
-                const current = await requireGoal(database, proposal.goalId);
+                const current = await requireGoalForUpdate(database, proposal.goalId);
                 assertCanonicalActiveGoal(current);
                 if (current.orgId !== proposal.orgId)
                     throw unprocessable("Goal Result Proposal organization mismatch");
                 if (current.contractRevision !== proposal.contractRevision) {
-                    throw conflict("Goal Contract revision changed before Result Proposal rejection");
+                    throw conflict("Goal changed before the result could be returned for more work");
                 }
-                await recordFeedback(database, current, {
+                const { dispatch } = await recordFeedback(database, current, {
                     body: input.feedback,
                     attachments: [],
                     feedbackKind: "ordinary",
@@ -1534,24 +2505,25 @@ export function goalService(db) {
                 }).where(and(eq(goalResultProposals.id, proposal.id), eq(goalResultProposals.status, "ready"))).returning().then((rows) => rows[0] ?? null);
                 if (!rejected)
                     throw conflict("Goal Result Proposal changed before rejection");
-                return rejected;
+                return { proposal: rejected, dispatch };
             });
         },
         assignOwner: async (id, input, actorAgentId = null) => {
-            const current = await requireGoal(db, id);
-            assertCanonicalActiveGoal(current);
-            assertGoalOwner(current, actorAgentId);
-            await requireInvokableOwner(db, current.orgId, input.agentId);
             return db.transaction(async (tx) => {
-                const previous = await tx.select().from(goalOwnerAssignments)
+                const database = tx;
+                const current = await requireGoalForUpdate(database, id);
+                assertCanonicalActiveGoal(current);
+                assertGoalOwner(current, actorAgentId);
+                await requireInvokableOwner(database, current.orgId, input.agentId);
+                const previous = await database.select().from(goalOwnerAssignments)
                     .where(and(eq(goalOwnerAssignments.goalId, id), isNull(goalOwnerAssignments.endsAt)))
                     .then((rows) => rows[0] ?? null);
                 if (previous?.agentId === input.agentId)
                     return previous;
                 const now = new Date();
                 if (previous)
-                    await tx.update(goalOwnerAssignments).set({ endsAt: now }).where(eq(goalOwnerAssignments.id, previous.id));
-                const [assignment] = await tx.insert(goalOwnerAssignments).values({
+                    await database.update(goalOwnerAssignments).set({ endsAt: now }).where(eq(goalOwnerAssignments.id, previous.id));
+                const [assignment] = await database.insert(goalOwnerAssignments).values({
                     orgId: current.orgId,
                     goalId: id,
                     agentId: input.agentId,
@@ -1559,26 +2531,36 @@ export function goalService(db) {
                     assignedByAuthorityRef: input.authorityRef ?? null,
                     startsAt: now,
                 }).returning();
-                await tx.update(goals).set({ ownerAgentId: input.agentId, updatedAt: now }).where(eq(goals.id, id));
+                const changedGoal = await database.update(goals).set({ ownerAgentId: input.agentId, ownerAgentRuntimeOverrides: null, updatedAt: now })
+                    .where(and(eq(goals.id, id), eq(goals.lifecycle, "active")))
+                    .returning().then((rows) => rows[0] ?? null);
+                if (!changedGoal)
+                    throw conflict("Goal changed before Owner assignment; reload and retry");
                 return assignment;
             });
         },
         setFocus: async (id, focus, actorAgentId = null) => {
-            const current = await requireGoal(db, id);
-            if (focus)
-                assertCanonicalActiveGoal(current);
-            assertGoalOwner(current, actorAgentId);
             return db.transaction(async (tx) => {
+                const database = tx;
+                const candidate = await requireGoal(database, id);
+                await database.execute(sql `select id from organizations where id = ${candidate.orgId} for update`);
+                const current = await requireGoalForUpdate(database, id);
+                if (current.orgId !== candidate.orgId)
+                    throw conflict("Goal organization changed before Focus update; reload and retry");
+                assertCanonicalActiveGoal(current);
+                assertGoalOwner(current, actorAgentId);
                 if (focus)
-                    await tx.update(goals).set({ focus: false }).where(eq(goals.orgId, current.orgId));
-                const [goal] = await tx.update(goals).set({ focus, updatedAt: new Date() }).where(eq(goals.id, id)).returning();
+                    await database.update(goals).set({ focus: false }).where(and(eq(goals.orgId, current.orgId), eq(goals.lifecycle, "active")));
+                const [goal] = await database.update(goals).set({ focus, updatedAt: new Date() }).where(and(eq(goals.id, id), eq(goals.lifecycle, "active"))).returning();
+                if (!goal)
+                    throw conflict("Goal changed before Focus update; reload and retry");
                 return goal;
             });
         },
         evaluate: async (id, input, actorAgentId = null) => {
             return db.transaction(async (tx) => {
                 const database = tx;
-                const current = await requireGoal(database, id);
+                const current = await requireGoalForUpdate(database, id);
                 return evaluateInTransaction(database, current, input, actorAgentId);
             });
         },