diff --git a/AGENTS.md b/AGENTS.md
index 8984a076e..071e007aa 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,15 +21,20 @@
 - The build does not clean `dist/`; remove stale output when deleting or renaming source modules before validating package contents.
 - Bundled prompts live in `src/prompts/`; bundled skills live in `skills/`. They sync on every plugin load, preserving user edits and never deleting files. The standalone installer handles conflicts and orphan pruning.
 - Keep the section-summary markers in `src/prompts/agents/auditor-loop-addendum.md` synchronized with the constants in `src/utils/section-summary.ts`.
+- Keep the four required headings in `src/prompts/agents/goal.md` synchronized with `GOAL_BRIEF_REQUIRED_HEADINGS` in `src/utils/goal-brief.ts`.
+- Goal launches from the TUI must set `initialPromptOwner: 'server'` so `attachLoopToSession` builds the prompt from `buildGoalCodingPrompt`. `buildTuiLoopInitialPrompt` is plan-only because it decomposes and sends section 1; it must not be reused for goal loops.
 - `MAX_TOTAL_SECTIONS` in `src/constants/loop.ts` is the single section cap; the decomposer, section bootstrap, plan structure summary, TUI inline plan preview and `plan-adjust` all read it, and the architect system reminder in `src/index.ts` interpolates it. `src/prompts/agents/architect.md` is prose and repeats the number literally — update it when the cap changes.
-- `PLAN_AUTHORING_TOOL_NAMES` in `src/constants/loop.ts` is the single list of plan-authoring tools; the `code`, `auditor`, and `feature-splitter` tool-exclude lists and both permission rulesets derive their deny entries from it.
+- `PLAN_AUTHORING_TOOL_NAMES` in `src/constants/loop.ts` is the single list of plan-authoring tools; the `code`, `auditor`, and `feature-splitter` tool-exclude lists derive their deny entries from it. `GOAL_AUTHORING_TOOL_NAMES` is the single list of goal-authoring tools (`goal-write` only). `SPEC_AUTHORING_TOOL_NAMES` (the plan list plus the goal list) is what `code`, `auditor`, and `feature-splitter` spread into their tool-exclude lists AND what both permission rulesets (`buildLoopPermissionRuleset`, `buildAuditSessionPermissionRuleset`) derive their deny entries from, so `goal-write` is denied in any running or audit session. The `architect` and `architect-auto` agents append `GOAL_AUTHORING_TOOL_NAMES` only (they keep `plan-write`/`plan-edit`). The `goal` agent spreads only `PLAN_AUTHORING_TOOL_NAMES` and is the **only** agent that may call `goal-write`. `assertWritableSession` in `src/tools/session-write-guard.ts` is the single shared guard both `plan-authoring.ts` and `goal-authoring.ts` call to reject writes from an active loop session.
 - `LoopService.resolveActiveLoopForSession` is the only correct "is this session inside a running loop" check. `resolveLoopName` matches terminated loops too, so using it as an activity guard blocks a session forever after its loop ends.
 - `resolveForgeDbPath` in `src/utils/opencode-paths.ts` is the only place `<dataDir>/forge.db` is built; every entry point must route through it so a configured `dataDir` is honoured uniformly.
+- `resolveLoopLaunchPolicy` in `src/utils/loop-helpers.ts` is the single resolution point for the loop launch policy (`loop.enabled` and `loop.defaultMaxIterations`). The `execute-plan`/`execute-goal` handlers in `src/services/execution.ts`, the TUI launch path in `src/utils/tui-client.ts`, the remote launch path in `src/utils/tui-remote-launch.ts`, and the attach hook fallback in `src/hooks/forge-session-attach.ts` all read it. The TUI/remote launch path stamps the resolved `maxIterations` onto the `forgeLoop` envelope (`ForgeLoopExtra.maxIterations`) so the attach hook honours the launcher's promise first and only falls back to the server-side policy when the stamp is absent. Local TUI launches set `awaitAttachAck` so `launchTuiLoop` polls the shared forge database for the running loop row before reporting success; remote launches cannot observe the remote database and remain fire-and-forget. `connectForgeProject` is the only TUI entry point that receives `pluginConfig`/`awaitAttachAck` (population from `src/tui.tsx`).
 
 ## Dashboard and storage gotchas
 
 - The dashboard browser app uses `solid-js/html`, not JSX. Do not use `<${Show}>` or `<${For}>`; use reactive thunks/memos and `.map()`. Every template needs a real root element, reactive regions must be functions such as `${() => ...}`, and the root component returns one wrapper element. `test/dashboard/app-dom.test.ts` enforces these constraints.
 - Storage migrations are registered explicitly, in execution order, in the lowercase `migrations` array in `src/storage/migrations/index.ts`; they are not discovered from filenames. Inline migrations are valid, so not every migration needs a SQL file.
+- `goal_briefs` is the pre-launch authoring store for goal briefs; `loop_large_fields.goal` remains the launched loop's copy. Goal loops still never write `plans` rows (`src/loop/service.ts:183-194`).
+- `fetchStoredSessionLaunchSpec` in `src/utils/tui-loop-store.ts` is the only place the dialog resolves a launchable artifact; it reads both stores (plans and goal briefs) in one DB open and the newest wins with plans breaking ties.
 - `resolveDashboardConfig` in `src/dashboard/config.ts` is the only place the dashboard bind host/port is resolved, and `DEFAULT_DASHBOARD_PORT`/`DEFAULT_DASHBOARD_HOST` are the only copies of the *bind* defaults. The literal `localhost` in `buildDashboardUrls` is deliberately separate: it is the loopback display URL and must not follow the configured bind host. Every launch surface (`scripts/dashboard.ts`, the TUI `forge.dashboard` command) must pass its overrides plus the loaded `PluginConfig` into `startDashboardServer` rather than resolving them itself, and must render `DashboardServerHandle.warnings` so an unusable value is never dropped silently on one surface only. The dashboard has no auth; `DASHBOARD_EXPOSED_WARNING` is the single warning string.
 
 ## Diagnostics
diff --git a/README.md b/README.md
index dd0735c15..99099bfba 100644
--- a/README.md
+++ b/README.md
@@ -104,7 +104,7 @@ Execution flow dialog with mode and model selection:
 ## Features
 
 - **Plans** — architect authors plans directly into SQL storage with `plan-write`/`plan-edit`; marked plans emitted in chat are still auto-captured
-- **Execution** — approved-plan launch paths plus direct `/execute-goal` loops in dedicated worktree sessions; plan loops can also target a configured remote opencode server (see [Configuration](docs/configuration.md#remotes))
+- **Execution** — approved-plan launch paths plus `/goal` brief-backed goal loops in dedicated worktree sessions (launched by the `goal` agent via `execute-goal` or from the Forge execution dialog); plan loops can also target a configured remote opencode server (see [Configuration](docs/configuration.md#remotes))
 - **Loops** — iterative coding/auditing with isolated git worktree and optional Docker sandbox
 - **Review Findings** — persistent, loop-scoped review findings across loop sessions
 - **TUI** — sidebar and execution dialog
@@ -112,7 +112,7 @@ Execution flow dialog with mode and model selection:
 
 ## Agents
 
-The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant used by loop audit sessions. See [Agents and slash commands](docs/agents-and-commands.md) for the full reference.
+The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant used by loop audit sessions, plus a `goal` agent for authoring goal briefs. See [Agents and slash commands](docs/agents-and-commands.md) for the full reference.
 
 | Agent | Mode | Description |
 |-------|------|-------------|
@@ -120,6 +120,7 @@ The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant
 | **architect** | primary | Read-only planning agent. Researches the codebase, designs implementation plans, and caches them for user approval before execution. |
 | **auditor** | subagent | Read-only code auditor for convention-aware reviews. Invoked via Task tool to review diffs, commits, branches, or PRs against stored conventions and decisions. |
 | **auditor-loop** | primary, hidden | Internal audit agent used for loop-runner audit sessions. |
+| **goal** | primary | Read-only brief-authoring agent. Reconnoiters the codebase, clarifies scope inline, and writes the session-scoped goal brief with `goal-write` for approval and execution via the Forge execution dialog. |
 
 The auditor agent is a read-only subagent that cannot edit source files or execute plans. It is invoked by other agents via the Task tool to review code changes against stored project conventions and decisions.
 
@@ -135,6 +136,7 @@ See [Tools reference](docs/tools.md) for full arguments, section-scoping behavio
 Forge provides these tool groups:
 
 - **Plan tools** — `plan-write`, `plan-edit`, `plan-read`, `section-read`, `plan-adjust`
+- **Goal brief tools** — `goal-write`, `execute-goal`
 - **Review tools** — `review-write`, `review-read`, `review-delete`
 - **Loop tools** — `execute-plan`, `execute-goal`, `loop-cancel`, `loop-status`
 - **Sandbox shell** — `sh` when a sandbox manager is available
@@ -144,7 +146,7 @@ Loops always run in an isolated git worktree; Docker sandbox is used automatical
 | Tool | Description |
 |------|-------------|
 | `execute-plan` | Execute a plan using an iterative development loop in an isolated git worktree, or `mode: new-session` to launch it in a fresh standalone session. Args: `title` required; `plan`, `loopName`, `mode` optional. |
-| `execute-goal` | Execute a free-text goal in rotating dedicated code and auditor sessions inside an isolated git worktree. Args: `goal` required; `title`, `loopName`, `maxIterations` optional. |
+| `execute-goal` | Launch a goal loop from the goal brief stored for the current session (authored with `goal-write`). Args: `title`, `loopName`, `maxIterations` optional. |
 | `loop-cancel` | Cancel an active loop by worktree name |
 | `loop-status` | List active/recent loops or get detailed status by worktree name, including cumulative token usage when available. Supports `restart=true` to restart any non-completed loop (`running`, `cancelled`, `errored`, `stalled`). Completed loops are history-only and cannot be restarted. |
 
@@ -157,7 +159,7 @@ Loops always run in an isolated git worktree; Docker sandbox is used automatical
 | `/review` | Run a code review on current changes | auditor (subtask) |
 | `/review-plan` | Review a completed implementation against its original plan | auditor (subtask) |
 | `/execute-plan` | Start an iterative development loop in a worktree (or a fresh session with `mode: new-session`) | code |
-| `/execute-goal` | Execute a free-text goal in dedicated worktree sessions until an audit leaves no findings | code |
+| `/goal` | Reconnoiter, author a goal brief (`goal-write`), and launch a goal loop — either directly via `execute-goal` or from the Forge execution dialog | goal |
 | `/loop-status` | Check status of all active loops | code |
 | `/loop-cancel` | Cancel the active loop | code |
 
diff --git a/docs/agents-and-commands.md b/docs/agents-and-commands.md
index 5430e1275..ad0e3550d 100644
--- a/docs/agents-and-commands.md
+++ b/docs/agents-and-commands.md
@@ -12,6 +12,7 @@ See also: [Tools](tools.md), [Configuration](configuration.md), [Loop System](lo
 | `architect` | `primary` | Read-only planning agent. Authors the stored plan with `plan-write`/`plan-edit` for approval and execution; marked plans in chat are still captured. |
 | `auditor` | `subagent` | Read-only code review agent for convention-aware reviews. |
 | `auditor-loop` | `primary`, hidden | Internal auditor used by loop audit sessions. |
+| `goal` | `primary` | Read-only brief-authoring agent. Reconnoiters the codebase, clarifies scope inline, and writes the session-scoped goal brief with `goal-write` for approval and execution. |
 
 Source: [`src/agents/index.ts`](../src/agents/index.ts), [`src/agents/auditor.ts`](../src/agents/auditor.ts).
 
@@ -29,6 +30,7 @@ Excluded tools:
 - `plan_exit`
 - `plan-write`
 - `plan-edit`
+- `goal-write`
 - `execute-plan`
 - `execute-goal`
 - `loop-cancel`
@@ -36,6 +38,14 @@ Excluded tools:
 
 Source: [`AUDITOR_TOOL_EXCLUDES`](../src/agents/auditor.ts).
 
+## Goal agent restrictions
+
+The `goal` agent is a read-only brief author and launcher. It can reconnoiter with read tools, ask the user clarifying questions, author the session-scoped goal brief with `goal-write`, and launch a goal loop from that brief with `execute-goal`. It cannot edit source files, run plan loops, author plans, or manage other loops.
+
+Excluded tools: every filesystem-mutating tool, every plan/loop/group management tool, and every plan-authoring tool (`plan-write`, `plan-edit`, `plan-adjust`). `execute-plan` is excluded (plan loops are not launched from the goal agent). The `goal` agent is the only agent allowed to call `goal-write`.
+
+Source: [`src/agents/goal.ts`](../src/agents/goal.ts), [`src/constants/loop.ts`](../src/constants/loop.ts).
+
 ## Slash Commands
 
 | Command | Description | Agent | Subtask |
@@ -43,7 +53,7 @@ Source: [`AUDITOR_TOOL_EXCLUDES`](../src/agents/auditor.ts).
 | `/review` | Run a code review. | `auditor` | yes |
 | `/review-plan` | Review a completed implementation against its original plan. | `auditor` | yes |
 | `/execute-plan` | Start an iterative development loop in a worktree (or launch the plan in a fresh standalone session with `mode: new-session`). | `code` | no |
-| `/execute-goal` | Execute a goal in rotating dedicated code and auditor sessions inside an isolated worktree. | `code` | no |
+| `/goal` | Reconnoiter, author a goal brief (`goal-write`), and launch a goal loop — either directly via `execute-goal` or from the Forge execution dialog. | `goal` | no |
 | `/loop-status` | Check status of all active loops. | `code` | no |
 | `/loop-cancel` | Cancel the active loop. | `code` | no |
 
diff --git a/docs/api/README.md b/docs/api/README.md
index 10db14722..09d7ca30f 100644
--- a/docs/api/README.md
+++ b/docs/api/README.md
@@ -107,7 +107,7 @@ Execution flow dialog with mode and model selection:
 ## Features
 
 - **Plans** — architect authors plans directly into SQL storage with `plan-write`/`plan-edit`; marked plans emitted in chat are still auto-captured
-- **Execution** — approved-plan launch paths plus direct `/execute-goal` loops in dedicated worktree sessions; plan loops can also target a configured remote opencode server (see [Configuration](_media/configuration.md#remotes))
+- **Execution** — approved-plan launch paths plus `/goal` brief-backed goal loops in dedicated worktree sessions (launched by the `goal` agent via `execute-goal` or from the Forge execution dialog); plan loops can also target a configured remote opencode server (see [Configuration](_media/configuration.md#remotes))
 - **Loops** — iterative coding/auditing with isolated git worktree and optional Docker sandbox
 - **Review Findings** — persistent, loop-scoped review findings across loop sessions
 - **TUI** — sidebar and execution dialog
@@ -115,7 +115,7 @@ Execution flow dialog with mode and model selection:
 
 ## Agents
 
-The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant used by loop audit sessions. See [Agents and slash commands](_media/agents-and-commands.md) for the full reference.
+The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant used by loop audit sessions, plus a `goal` agent for authoring goal briefs. See [Agents and slash commands](_media/agents-and-commands.md) for the full reference.
 
 | Agent | Mode | Description |
 |-------|------|-------------|
@@ -123,6 +123,7 @@ The plugin bundles three user-facing agents plus a hidden `auditor-loop` variant
 | **architect** | primary | Read-only planning agent. Researches the codebase, designs implementation plans, and caches them for user approval before execution. |
 | **auditor** | subagent | Read-only code auditor for convention-aware reviews. Invoked via Task tool to review diffs, commits, branches, or PRs against stored conventions and decisions. |
 | **auditor-loop** | primary, hidden | Internal audit agent used for loop-runner audit sessions. |
+| **goal** | primary | Read-only brief-authoring agent. Reconnoiters the codebase, clarifies scope inline, and writes the session-scoped goal brief with `goal-write` for approval and execution via the Forge execution dialog. |
 
 The auditor agent is a read-only subagent that cannot edit source files or execute plans. It is invoked by other agents via the Task tool to review code changes against stored project conventions and decisions.
 
@@ -137,6 +138,7 @@ See [Tools reference](_media/tools.md) for full arguments, section-scoping behav
 Forge provides these tool groups:
 
 - **Plan tools** — `plan-write`, `plan-edit`, `plan-read`, `section-read`, `plan-adjust`
+- **Goal brief tools** — `goal-write`, `execute-goal`
 - **Review tools** — `review-write`, `review-read`, `review-delete`
 - **Loop tools** — `execute-plan`, `execute-goal`, `loop-cancel`, `loop-status`
 - **Sandbox shell** — `sh` when a sandbox manager is available
@@ -146,7 +148,7 @@ Loops always run in an isolated git worktree; Docker sandbox is used automatical
 | Tool | Description |
 |------|-------------|
 | `execute-plan` | Execute a plan using an iterative development loop in an isolated git worktree, or `mode: new-session` to launch it in a fresh standalone session. Args: `title` required; `plan`, `loopName`, `mode` optional. |
-| `execute-goal` | Execute a free-text goal in rotating dedicated code and auditor sessions inside an isolated git worktree. Args: `goal` required; `title`, `loopName`, `maxIterations` optional. |
+| `execute-goal` | Launch a goal loop from the goal brief stored for the current session (authored with `goal-write`). Args: `title`, `loopName`, `maxIterations` optional. |
 | `loop-cancel` | Cancel an active loop by worktree name |
 | `loop-status` | List active/recent loops or get detailed status by worktree name, including cumulative token usage when available. Supports `restart=true` to restart any non-completed loop (`running`, `cancelled`, `errored`, `stalled`). Completed loops are history-only and cannot be restarted. |
 
@@ -159,7 +161,7 @@ Loops always run in an isolated git worktree; Docker sandbox is used automatical
 | `/review` | Run a code review on current changes | auditor (subtask) |
 | `/review-plan` | Review a completed implementation against its original plan | auditor (subtask) |
 | `/execute-plan` | Start an iterative development loop in a worktree (or a fresh session with `mode: new-session`) | code |
-| `/execute-goal` | Execute a free-text goal in dedicated worktree sessions until an audit leaves no findings | code |
+| `/goal` | Reconnoiter, author a goal brief (`goal-write`), and launch a goal loop — either directly via `execute-goal` or from the Forge execution dialog | goal |
 | `/loop-status` | Check status of all active loops | code |
 | `/loop-cancel` | Cancel the active loop | code |
 
diff --git a/docs/api/_media/agents-and-commands.md b/docs/api/_media/agents-and-commands.md
index 5430e1275..ad0e3550d 100644
--- a/docs/api/_media/agents-and-commands.md
+++ b/docs/api/_media/agents-and-commands.md
@@ -12,6 +12,7 @@ See also: [Tools](tools.md), [Configuration](configuration.md), [Loop System](lo
 | `architect` | `primary` | Read-only planning agent. Authors the stored plan with `plan-write`/`plan-edit` for approval and execution; marked plans in chat are still captured. |
 | `auditor` | `subagent` | Read-only code review agent for convention-aware reviews. |
 | `auditor-loop` | `primary`, hidden | Internal auditor used by loop audit sessions. |
+| `goal` | `primary` | Read-only brief-authoring agent. Reconnoiters the codebase, clarifies scope inline, and writes the session-scoped goal brief with `goal-write` for approval and execution. |
 
 Source: [`src/agents/index.ts`](../src/agents/index.ts), [`src/agents/auditor.ts`](../src/agents/auditor.ts).
 
@@ -29,6 +30,7 @@ Excluded tools:
 - `plan_exit`
 - `plan-write`
 - `plan-edit`
+- `goal-write`
 - `execute-plan`
 - `execute-goal`
 - `loop-cancel`
@@ -36,6 +38,14 @@ Excluded tools:
 
 Source: [`AUDITOR_TOOL_EXCLUDES`](../src/agents/auditor.ts).
 
+## Goal agent restrictions
+
+The `goal` agent is a read-only brief author and launcher. It can reconnoiter with read tools, ask the user clarifying questions, author the session-scoped goal brief with `goal-write`, and launch a goal loop from that brief with `execute-goal`. It cannot edit source files, run plan loops, author plans, or manage other loops.
+
+Excluded tools: every filesystem-mutating tool, every plan/loop/group management tool, and every plan-authoring tool (`plan-write`, `plan-edit`, `plan-adjust`). `execute-plan` is excluded (plan loops are not launched from the goal agent). The `goal` agent is the only agent allowed to call `goal-write`.
+
+Source: [`src/agents/goal.ts`](../src/agents/goal.ts), [`src/constants/loop.ts`](../src/constants/loop.ts).
+
 ## Slash Commands
 
 | Command | Description | Agent | Subtask |
@@ -43,7 +53,7 @@ Source: [`AUDITOR_TOOL_EXCLUDES`](../src/agents/auditor.ts).
 | `/review` | Run a code review. | `auditor` | yes |
 | `/review-plan` | Review a completed implementation against its original plan. | `auditor` | yes |
 | `/execute-plan` | Start an iterative development loop in a worktree (or launch the plan in a fresh standalone session with `mode: new-session`). | `code` | no |
-| `/execute-goal` | Execute a goal in rotating dedicated code and auditor sessions inside an isolated worktree. | `code` | no |
+| `/goal` | Reconnoiter, author a goal brief (`goal-write`), and launch a goal loop — either directly via `execute-goal` or from the Forge execution dialog. | `goal` | no |
 | `/loop-status` | Check status of all active loops. | `code` | no |
 | `/loop-cancel` | Cancel the active loop. | `code` | no |
 
diff --git a/docs/api/_media/architecture.md b/docs/api/_media/architecture.md
index 84320e424..8a7c2c510 100644
--- a/docs/api/_media/architecture.md
+++ b/docs/api/_media/architecture.md
@@ -63,13 +63,13 @@ The codebase is organized into these module groups under `src/`:
 
 | Module | Purpose | Key Files |
 |--------|---------|-----------|
-| `agents/` | AI agent definitions (code, architect, auditor + auditor-loop variant) | `index.ts`, `code.ts`, `architect.ts`, `auditor.ts` |
+| `agents/` | AI agent definitions (code, architect, goal, auditor + auditor-loop variant) | `index.ts`, `code.ts`, `architect.ts`, `goal.ts`, `auditor.ts` |
 | `hooks/` | Plugin event/lifecycle hooks (session, loop events, plan capture, plan approval, watchdog, sandbox, forge-session-attach, loop-permission, host-side-effects) | `index.ts`, `session.ts`, `loop.ts`, `plan-capture.ts`, `plan-approval.ts`, `watchdog.ts`, `sandbox-tools.ts`, `forge-session-attach.ts`, `loop-permission.ts`, `host-side-effects.ts` |
 | `loop/` | Core loop state machine and runtime | `runtime.ts`, `service.ts`, `state.ts`, `transitions.ts`, `prompts.ts`, `restartability.ts`, `in-flight-guard.ts`, `token-usage.ts`, `name-uniqueness.ts` |
 | `services/` | Higher-level orchestration services | `execution.ts`, `session-loop-resolver.ts`, `deterministic-decomposer.ts`, `plan-capture.ts`, `worktree-log.ts` |
 | `sandbox/` | Docker sandbox management | `docker.ts`, `manager.ts`, `context.ts`, `reconcile.ts` |
 | `storage/` | SQLite persistence layer (repos + migrations) | `database.ts`, `repos/*.ts`, `migrations/*.sql` |
-| `tools/` | Plugin tools callable by AI agents | `loop.ts`, `review.ts`, `plan-kv.ts`, `section-read.ts` |
+| `tools/` | Plugin tools callable by AI agents | `loop.ts`, `review.ts`, `plan-kv.ts`, `plan-authoring.ts`, `goal-authoring.ts`, `section-read.ts` |
 | `workspace/` | Git worktree / workspace management | `forge-adapter.ts`, `forge-worktree.ts`, `pending-teardown.ts`, `classify-stale.ts`, `remove-with-context.ts`, `sweep-stale.ts` |
 | `utils/` | Shared utility modules (~25 files) | `logger.ts`, `lru-cache.ts`, `model-fallback.ts`, etc. |
 | `tui/` | TUI-specific components | `execute-plan-panel.tsx` |
@@ -167,7 +167,7 @@ OpenCode Forge uses `bun:sqlite` for all data persistence. The storage layer is
 - `initializeDatabase(dataDir, options)` - Creates SQLite DB in the data directory
 - `closeDatabase()` - Closes database connections on shutdown
 - `resolveDataDir()` - Resolves platform-appropriate data directory (`~/.local/share/opencode/forge`)
-- Migrations are registered explicitly in execution order (ids 100-143; not every id ships a SQL file) and tracked in a `migrations` table
+- Migrations are registered explicitly in execution order (ids 100-144; not every id ships a SQL file) and tracked in a `migrations` table
 
 ### Repository Pattern
 
@@ -177,6 +177,7 @@ All data access goes through typed repository interfaces created via factory fun
 |---|---|---|
 | `LoopsRepo` | CRUD for loop rows | `LoopRow`, `LoopLargeFields` |
 | `PlansRepo` | CRUD for plans (session-scoped plan of record read by `plan-read`, the approval hook, `execute-plan`, and the TUI plan dialog) | `PlanRow`, `PlansRepo` |
+| `GoalBriefsRepo` | CRUD for session-scoped goal briefs authored before goal-loop launch | `GoalBriefRow`, `GoalBriefsRepo` |
 | `ReviewFindingsRepo` | CRUD for review findings | `ReviewFindingRow`, `ReviewFindingsRepo` |
 | `SectionPlansRepo` | CRUD for milestone (section) plans used in decomposed loops | `SectionPlanRow`, `SectionPlansRepo` |
 | `LoopTransitionsRepo` | Append-only loop phase-transition log | `LoopTransitionRow` |
diff --git a/docs/api/_media/loop-system.md b/docs/api/_media/loop-system.md
index eccbbff22..5354aa9ef 100644
--- a/docs/api/_media/loop-system.md
+++ b/docs/api/_media/loop-system.md
@@ -294,12 +294,17 @@ Cancellation:
 
 ## Goal Loops
 
-A **goal loop** (`kind: 'goal'`) is a lightweight alternative to a plan loop for work that does not need a structured plan. It is started by the `/execute-goal <prompt>` slash command (or the `execute-goal` tool) with free-text goal text.
+A **goal loop** (`kind: 'goal'`) is a lightweight alternative to a plan loop for work that does not need a structured plan. Every goal loop is launched from a **goal brief** authored by the `goal` agent with `goal-write` and persisted to a session-scoped `goal_briefs` row. Forge exposes two launch surfaces for that brief:
+
+- **`execute-goal` tool** — the `goal` agent calls it directly after authoring a clean brief. It reads the stored brief and starts a managed goal loop with the plugin-config default execution and auditor models.
+- **Forge execution dialog** — the user opens the dialog to pick the execution model, auditor model, and other launch options, then launches the brief-backed goal loop from there.
+
+Both surfaces read the same stored brief, so the auditor contract is identical regardless of which one launches the loop.
 
 ### Lifecycle differences from plan loops
 
-- **No plan, no decomposition, no approval.** The goal text is persisted in `loop_large_fields.goal` (never in the `plans` table) and is the auditor's authoritative scope. There are no sections, no `final_auditing` phase, and no `post_action` phase.
-- **Dedicated rotating sessions.** Forge creates a code session in the isolated worktree, sends the goal as its initial prompt, and leaves the invoking session unchanged as the post-completion host redirect target. As with plan loops, each completed code or audit pass is retired before the next session takes over.
+- **No plan, no decomposition, no approval.** The brief text is persisted in `loop_large_fields.goal` (never in the `plans` table) and is the auditor's authoritative scope. There are no sections, no `final_auditing` phase, and no `post_action` phase.
+- **Dedicated rotating sessions.** Forge creates a code session in the isolated worktree, sends the brief as its initial prompt, and leaves the invoking session unchanged as the post-completion host redirect target. As with plan loops, each completed code or audit pass is retired before the next session takes over.
 - **Idle-driven audits.** When the executor goes idle, the loop runner starts a fresh `auditor-loop` session against the worktree (same as plan loops). The auditor verifies both goal completion and code correctness, and may block termination with `severity: "bug"` findings (using the stable pseudo-path `GOAL` with `line: 1` when no source location applies for an unmet part of the goal).
 - **Dirty audits create a fresh code session.** When findings remain, Forge creates and selects a new code session in the worktree and sends a continuation prompt containing the goal and outstanding findings. That session goes idle to trigger the next audit.
 - **Clean audits terminate immediately.** When a completed auditor pass leaves zero outstanding review findings (any severity), the loop terminates with `completed` — no final audit, no post-completion action.
@@ -316,18 +321,22 @@ A goal loop completes only after the auditor has run at least once and leaves no
 
 Goal loops are fully visible to `loop-status`, cancellable with `loop-cancel`, and restartable with `loop-status ... restart=true`. Restart preserves the goal kind and goal text, skips plan decomposition, and resumes from a fresh session.
 
-`execute-goal` is added to the same loop/audit denial lists as `execute-plan`, `launch-group`, and the group tools, so an active executor or auditor session cannot recursively start another goal loop. Auditors exclude `execute-goal` from their tools.
+`execute-goal` is added to the same loop/audit denial lists as `execute-plan`, `launch-group`, and the group tools, so an active executor or auditor session cannot recursively start another goal loop. Auditors exclude `execute-goal` from their tools. The `goal` agent runs in the user's briefing session (not a loop session), so it is the one surface allowed to call `execute-goal`.
 
 ### Differences from `execute-plan` and `launch-group`
 
-| Aspect | `execute-plan` (loop) | `execute-goal` | `launch-group` |
+| Aspect | `execute-plan` (loop) | `/goal` brief → goal loop | `launch-group` |
 |---|---|---|---|
-| Input | Structured plan (persisted in `plans`) | Free-text goal | PRD / pre-split feature list |
+| Input | Structured plan (persisted in `plans`) | Structured goal brief (persisted in `goal_briefs`) | PRD / pre-split feature list |
 | Sections / milestones | Yes (decomposed) | No | Per feature (each feature is its own loop) |
 | Executor session | Fresh session per iteration | Fresh dedicated session per coding pass | Fresh session per feature loop |
 | Final audit | Yes (after all sections) | No | Per feature loop |
 | Post-completion action | Yes (when configured) | Never | Per feature loop |
-| Slash command | `/execute-plan` | `/execute-goal` | None (agent-invoked) |
+| Stored artifact | `plans` row | `goal_briefs` row pre-launch; `loop_large_fields.goal` after launch | Per-feature `plans` rows |
+| Model selection | Execution dialog (executor + auditor) | `execute-goal` tool (config defaults) or execution dialog | Execution dialog per feature |
+| Slash command | `/execute-plan` | `/goal` | None (agent-invoked) |
+
+The brief's `## Acceptance Criteria` section becomes the frozen spec re-read by `buildGoalAuditPrompt` on every audit pass: once a brief-backed goal loop launches, the brief text is copied into `loop_large_fields.goal` and the auditor compares the worktree against that exact text on every pass. The structured acceptance criteria give the auditor a stable, reviewable contract instead of a one-line free-text prompt.
 
 ## Tool Restrictions
 
diff --git a/docs/api/_media/tools.md b/docs/api/_media/tools.md
index f6306243d..da9a97f65 100644
--- a/docs/api/_media/tools.md
+++ b/docs/api/_media/tools.md
@@ -13,11 +13,12 @@ See also: [Agents and Slash Commands](agents-and-commands.md), [Configuration](c
 | `plan-edit` | Edit the stored session plan by exact string replacement. | [`src/tools/plan-authoring.ts`](../src/tools/plan-authoring.ts) |
 | `section-read` | Read a section plan and status for the active loop session. | [`src/tools/section-read.ts`](../src/tools/section-read.ts) |
 | `plan-adjust` | Revise the section under audit and/or replace the remaining (not yet started) sections of the active loop plan; auditor-only, logged as a plan amendment. | [`src/tools/plan-adjust.ts`](../src/tools/plan-adjust.ts) |
+| `goal-write` | Write the session-scoped goal brief that seeds a goal loop. | [`src/tools/goal-authoring.ts`](../src/tools/goal-authoring.ts) |
 | `review-write` | Store a review finding. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `review-read` | Read review findings. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `review-delete` | Delete a review finding. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `execute-plan` | Start an iterative development loop in an isolated git worktree, or (with `mode: new-session`) launch the plan in a fresh standalone session. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
-| `execute-goal` | Start a managed goal loop in a dedicated code session inside an isolated Forge worktree. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
+| `execute-goal` | Launch a managed goal loop from the goal brief stored for the current session (`goal-write`). | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `loop-cancel` | Cancel an active loop. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `loop-status` | List loops, inspect one loop, or restart a restartable loop. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `launch-group` | Launch a group of features (from a PRD or a pre-split list), each planned and run as its own loop, scheduled with a concurrency cap. | [`src/tools/group.ts`](../src/tools/group.ts) |
@@ -66,6 +67,19 @@ Arguments:
 
 `plan-write` and `plan-edit` author the plan before execution; `plan-adjust` amends an already-running sectioned loop's plan during a section audit and is auditor-only.
 
+### `goal-write`
+
+Writes the session-scoped **goal brief** that seeds a goal loop, the goal-mode counterpart of `plan-write`. Available to the `goal` agent only; denied in `code`, `auditor`, `auditor-loop`, `feature-splitter`, `architect`, and `architect-auto` sessions, and inside any running loop or audit session. Denied when the session owns a running loop, the same shared guard `plan-authoring.ts` uses.
+
+Reports missing required headings as warnings, and rejects `## Phase` headings or `<!-- forge-section -->` markers without writing. A brief with heading warnings still persists so the agent can inspect the report and correct it. Accepts `append` to grow the brief incrementally. On success the brief is persisted to the session-scoped `goal_briefs` row and the tool returns a structure report with line/character counts and warnings.
+
+Arguments:
+
+| Argument | Description |
+|---|---|
+| `content` | Goal brief markdown. Must contain the required headings; must not contain `## Phase` headings or `<!-- forge-section -->` markers. |
+| `append` | Append to the existing stored brief instead of replacing it. Two newlines are inserted between the existing content and the new fragment. Creates the brief when none exists. |
+
 ## Section Tools
 
 ### `section-read`
@@ -141,22 +155,23 @@ Arguments:
 | `title` | Required short title for the session list. |
 | `plan` | Optional inline plan. If omitted, Forge reads the current session's stored plan. |
 | `loopName` | Optional loop name, slugified and uniquified. |
-| `hostSessionId` | Optional host session ID for post-completion redirect. |
 | `mode` | Execution mode. `loop` (default) runs the iterative loop in an isolated git worktree. `new-session` launches the plan in a fresh standalone session running the code agent (no worktree, no loop, not tracked by `loop-status`/`loop-cancel`). |
 
 ### `execute-goal`
 
-Starts a managed **goal loop** from free-text goal input, with no plan, decomposition, approval flow, final audit, or post-action. Forge creates a dedicated code session inside an isolated worktree and sends the goal as its initial prompt. When that coding pass goes idle, Forge replaces it with a fresh auditor session; a dirty audit then creates a fresh code session for remediation. The invoking session remains the host redirect target and is not warped into the worktree.
+Launches a managed **goal loop** from the goal brief stored for the current session (authored with `goal-write`), with no plan, decomposition, approval flow, final audit, or post-action. There is no `goal` argument — the tool reads the stored brief, refuses to launch when the brief is missing or incomplete (missing required `##` headings), and dispatches the brief as the goal. Forge creates a dedicated code session inside an isolated worktree and sends the brief as its initial prompt. When that coding pass goes idle, Forge replaces it with a fresh auditor session; a dirty audit then creates a fresh code session for remediation. The invoking session remains the host redirect target and is not warped into the worktree.
+
+The `goal` agent calls this tool directly after authoring a clean brief; the Forge execution dialog is the alternate launch surface when the user wants to pick models. `execute-goal` uses the plugin-config default execution and auditor models.
 
 Arguments:
 
 | Argument | Description |
 |---|---|
-| `goal` | Required. Non-empty free text describing the goal; the first line is used to derive a title/loop name when omitted. |
-| `title` | Optional short title for the loop (derived from the goal when omitted). |
+| `title` | Optional short title for the loop (derived from the brief's `## Goal` when omitted). |
 | `loopName` | Optional loop name, slugified and uniquified. |
 | `maxIterations` | Optional maximum loop iterations. Defaults to the plugin config `loop.defaultMaxIterations`; `0` means unlimited (run until auditor all-clear or cancellation). |
-| `hostSessionId` | Optional host session ID for post-completion redirect; defaults to the invoking (`execute-goal`) session. |
+
+The invoking session is automatically used as the post-completion host redirect target; `execute-goal` does not expose a `hostSessionId` argument.
 
 Worktree/session behavior, auditor/finding completion rule, iteration cap, and differences from `execute-plan` and `launch-group` are documented in [Loop System → Goal Loops](loop-system.md#goal-loops).
 
diff --git a/docs/architecture.md b/docs/architecture.md
index 84320e424..8a7c2c510 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -63,13 +63,13 @@ The codebase is organized into these module groups under `src/`:
 
 | Module | Purpose | Key Files |
 |--------|---------|-----------|
-| `agents/` | AI agent definitions (code, architect, auditor + auditor-loop variant) | `index.ts`, `code.ts`, `architect.ts`, `auditor.ts` |
+| `agents/` | AI agent definitions (code, architect, goal, auditor + auditor-loop variant) | `index.ts`, `code.ts`, `architect.ts`, `goal.ts`, `auditor.ts` |
 | `hooks/` | Plugin event/lifecycle hooks (session, loop events, plan capture, plan approval, watchdog, sandbox, forge-session-attach, loop-permission, host-side-effects) | `index.ts`, `session.ts`, `loop.ts`, `plan-capture.ts`, `plan-approval.ts`, `watchdog.ts`, `sandbox-tools.ts`, `forge-session-attach.ts`, `loop-permission.ts`, `host-side-effects.ts` |
 | `loop/` | Core loop state machine and runtime | `runtime.ts`, `service.ts`, `state.ts`, `transitions.ts`, `prompts.ts`, `restartability.ts`, `in-flight-guard.ts`, `token-usage.ts`, `name-uniqueness.ts` |
 | `services/` | Higher-level orchestration services | `execution.ts`, `session-loop-resolver.ts`, `deterministic-decomposer.ts`, `plan-capture.ts`, `worktree-log.ts` |
 | `sandbox/` | Docker sandbox management | `docker.ts`, `manager.ts`, `context.ts`, `reconcile.ts` |
 | `storage/` | SQLite persistence layer (repos + migrations) | `database.ts`, `repos/*.ts`, `migrations/*.sql` |
-| `tools/` | Plugin tools callable by AI agents | `loop.ts`, `review.ts`, `plan-kv.ts`, `section-read.ts` |
+| `tools/` | Plugin tools callable by AI agents | `loop.ts`, `review.ts`, `plan-kv.ts`, `plan-authoring.ts`, `goal-authoring.ts`, `section-read.ts` |
 | `workspace/` | Git worktree / workspace management | `forge-adapter.ts`, `forge-worktree.ts`, `pending-teardown.ts`, `classify-stale.ts`, `remove-with-context.ts`, `sweep-stale.ts` |
 | `utils/` | Shared utility modules (~25 files) | `logger.ts`, `lru-cache.ts`, `model-fallback.ts`, etc. |
 | `tui/` | TUI-specific components | `execute-plan-panel.tsx` |
@@ -167,7 +167,7 @@ OpenCode Forge uses `bun:sqlite` for all data persistence. The storage layer is
 - `initializeDatabase(dataDir, options)` - Creates SQLite DB in the data directory
 - `closeDatabase()` - Closes database connections on shutdown
 - `resolveDataDir()` - Resolves platform-appropriate data directory (`~/.local/share/opencode/forge`)
-- Migrations are registered explicitly in execution order (ids 100-143; not every id ships a SQL file) and tracked in a `migrations` table
+- Migrations are registered explicitly in execution order (ids 100-144; not every id ships a SQL file) and tracked in a `migrations` table
 
 ### Repository Pattern
 
@@ -177,6 +177,7 @@ All data access goes through typed repository interfaces created via factory fun
 |---|---|---|
 | `LoopsRepo` | CRUD for loop rows | `LoopRow`, `LoopLargeFields` |
 | `PlansRepo` | CRUD for plans (session-scoped plan of record read by `plan-read`, the approval hook, `execute-plan`, and the TUI plan dialog) | `PlanRow`, `PlansRepo` |
+| `GoalBriefsRepo` | CRUD for session-scoped goal briefs authored before goal-loop launch | `GoalBriefRow`, `GoalBriefsRepo` |
 | `ReviewFindingsRepo` | CRUD for review findings | `ReviewFindingRow`, `ReviewFindingsRepo` |
 | `SectionPlansRepo` | CRUD for milestone (section) plans used in decomposed loops | `SectionPlanRow`, `SectionPlansRepo` |
 | `LoopTransitionsRepo` | Append-only loop phase-transition log | `LoopTransitionRow` |
diff --git a/docs/loop-system.md b/docs/loop-system.md
index eccbbff22..5354aa9ef 100644
--- a/docs/loop-system.md
+++ b/docs/loop-system.md
@@ -294,12 +294,17 @@ Cancellation:
 
 ## Goal Loops
 
-A **goal loop** (`kind: 'goal'`) is a lightweight alternative to a plan loop for work that does not need a structured plan. It is started by the `/execute-goal <prompt>` slash command (or the `execute-goal` tool) with free-text goal text.
+A **goal loop** (`kind: 'goal'`) is a lightweight alternative to a plan loop for work that does not need a structured plan. Every goal loop is launched from a **goal brief** authored by the `goal` agent with `goal-write` and persisted to a session-scoped `goal_briefs` row. Forge exposes two launch surfaces for that brief:
+
+- **`execute-goal` tool** — the `goal` agent calls it directly after authoring a clean brief. It reads the stored brief and starts a managed goal loop with the plugin-config default execution and auditor models.
+- **Forge execution dialog** — the user opens the dialog to pick the execution model, auditor model, and other launch options, then launches the brief-backed goal loop from there.
+
+Both surfaces read the same stored brief, so the auditor contract is identical regardless of which one launches the loop.
 
 ### Lifecycle differences from plan loops
 
-- **No plan, no decomposition, no approval.** The goal text is persisted in `loop_large_fields.goal` (never in the `plans` table) and is the auditor's authoritative scope. There are no sections, no `final_auditing` phase, and no `post_action` phase.
-- **Dedicated rotating sessions.** Forge creates a code session in the isolated worktree, sends the goal as its initial prompt, and leaves the invoking session unchanged as the post-completion host redirect target. As with plan loops, each completed code or audit pass is retired before the next session takes over.
+- **No plan, no decomposition, no approval.** The brief text is persisted in `loop_large_fields.goal` (never in the `plans` table) and is the auditor's authoritative scope. There are no sections, no `final_auditing` phase, and no `post_action` phase.
+- **Dedicated rotating sessions.** Forge creates a code session in the isolated worktree, sends the brief as its initial prompt, and leaves the invoking session unchanged as the post-completion host redirect target. As with plan loops, each completed code or audit pass is retired before the next session takes over.
 - **Idle-driven audits.** When the executor goes idle, the loop runner starts a fresh `auditor-loop` session against the worktree (same as plan loops). The auditor verifies both goal completion and code correctness, and may block termination with `severity: "bug"` findings (using the stable pseudo-path `GOAL` with `line: 1` when no source location applies for an unmet part of the goal).
 - **Dirty audits create a fresh code session.** When findings remain, Forge creates and selects a new code session in the worktree and sends a continuation prompt containing the goal and outstanding findings. That session goes idle to trigger the next audit.
 - **Clean audits terminate immediately.** When a completed auditor pass leaves zero outstanding review findings (any severity), the loop terminates with `completed` — no final audit, no post-completion action.
@@ -316,18 +321,22 @@ A goal loop completes only after the auditor has run at least once and leaves no
 
 Goal loops are fully visible to `loop-status`, cancellable with `loop-cancel`, and restartable with `loop-status ... restart=true`. Restart preserves the goal kind and goal text, skips plan decomposition, and resumes from a fresh session.
 
-`execute-goal` is added to the same loop/audit denial lists as `execute-plan`, `launch-group`, and the group tools, so an active executor or auditor session cannot recursively start another goal loop. Auditors exclude `execute-goal` from their tools.
+`execute-goal` is added to the same loop/audit denial lists as `execute-plan`, `launch-group`, and the group tools, so an active executor or auditor session cannot recursively start another goal loop. Auditors exclude `execute-goal` from their tools. The `goal` agent runs in the user's briefing session (not a loop session), so it is the one surface allowed to call `execute-goal`.
 
 ### Differences from `execute-plan` and `launch-group`
 
-| Aspect | `execute-plan` (loop) | `execute-goal` | `launch-group` |
+| Aspect | `execute-plan` (loop) | `/goal` brief → goal loop | `launch-group` |
 |---|---|---|---|
-| Input | Structured plan (persisted in `plans`) | Free-text goal | PRD / pre-split feature list |
+| Input | Structured plan (persisted in `plans`) | Structured goal brief (persisted in `goal_briefs`) | PRD / pre-split feature list |
 | Sections / milestones | Yes (decomposed) | No | Per feature (each feature is its own loop) |
 | Executor session | Fresh session per iteration | Fresh dedicated session per coding pass | Fresh session per feature loop |
 | Final audit | Yes (after all sections) | No | Per feature loop |
 | Post-completion action | Yes (when configured) | Never | Per feature loop |
-| Slash command | `/execute-plan` | `/execute-goal` | None (agent-invoked) |
+| Stored artifact | `plans` row | `goal_briefs` row pre-launch; `loop_large_fields.goal` after launch | Per-feature `plans` rows |
+| Model selection | Execution dialog (executor + auditor) | `execute-goal` tool (config defaults) or execution dialog | Execution dialog per feature |
+| Slash command | `/execute-plan` | `/goal` | None (agent-invoked) |
+
+The brief's `## Acceptance Criteria` section becomes the frozen spec re-read by `buildGoalAuditPrompt` on every audit pass: once a brief-backed goal loop launches, the brief text is copied into `loop_large_fields.goal` and the auditor compares the worktree against that exact text on every pass. The structured acceptance criteria give the auditor a stable, reviewable contract instead of a one-line free-text prompt.
 
 ## Tool Restrictions
 
diff --git a/docs/modules.md b/docs/modules.md
index 0f3bfe715..bc2105580 100644
--- a/docs/modules.md
+++ b/docs/modules.md
@@ -73,13 +73,14 @@ Defines roles and system prompts for each AI agent used in the forge pipeline.
 | `code.ts` | Code execution agent |
 | `architect.ts` | Read-only planning/design agent |
 | `auditor.ts` | Code review agent + auditor-loop variant |
+| `goal.ts` | Read-only brief-authoring agent (writes session-scoped goal briefs with `goal-write`) |
 
 ### Public API
 
 ```typescript
 buildAgents(): Record<AgentRole, AgentDefinition>
 
-type AgentRole = 'code' | 'architect' | 'auditor' | 'auditor-loop'
+type AgentRole = 'code' | 'architect' | 'auditor' | 'auditor-loop' | 'architect-auto' | 'feature-splitter' | 'goal'
 ```
 
 Source: [src/agents/index.ts](../src/agents/index.ts)
@@ -346,10 +347,11 @@ Each created via `createXxxRepo(db)` factory with project-scoped queries:
 | `PlanAmendmentsRepo` | `plan_amendments` | `PlanAmendmentRow` — append-only plan-amendment audit trail |
 | `LoopSessionUsageRepo` | `loop_session_usage` | `LoopSessionUsageRow`, `LoopUsageAggregate` |
 | `TuiPrefsRepo` | `tui_preferences` | N/A |
+| `GoalBriefsRepo` | `goal_briefs` | Session-scoped goal briefs authored with `goal-write` before launching a goal loop |
 
 ### Migrations
 
-Migrations are registered explicitly, in execution order, in the `migrations` array (ids 100–143; inline migrations are valid, so not every id ships a `.sql` file) and tracked in a `migrations` table.
+Migrations are registered explicitly, in execution order, in the `migrations` array (ids 100–144; inline migrations are valid, so not every id ships a `.sql` file) and tracked in a `migrations` table.
 
 See [storage/migrations/README.md](../src/storage/migrations/README.md) for migration details.
 
@@ -373,8 +375,9 @@ Implements tools callable by AI agents during conversations.
 | `plan-read` | `plan-kv.ts` | Retrieve plans with pagination and pattern search |
 | `section-read` | `section-read.ts` | Retrieve a specific section of a plan |
 | `plan-adjust` | `plan-adjust.ts` | Auditor-only: revise the section under audit and/or replace the remaining sections of the active loop plan (logged as a plan amendment) |
-| `execute-plan` | `loop.ts` | Execute a plan using an iterative development loop, or `mode: new-session` for a fresh standalone session. Args: `title` required; `plan`, `loopName`, `hostSessionId`, `mode` optional. |
-| `execute-goal` | `loop.ts` | Execute a non-empty goal in a dedicated session inside a managed worktree. Args: `goal` required; `title`, `loopName`, `maxIterations`, `hostSessionId` optional. |
+| `goal-write` | `goal-authoring.ts` | `goal` agent-only: validate, persist, or append the session-scoped goal brief; denied in any running loop or audit session. Returns a structure report. |
+| `execute-plan` | `loop.ts` | Execute a plan using an iterative development loop, or `mode: new-session` for a fresh standalone session. Args: `title` required; `plan`, `loopName`, `mode` optional. |
+| `execute-goal` | `loop.ts` | Launch a goal loop from the goal brief stored for the current session (authored with `goal-write`); refuses when no brief is stored or the brief is incomplete. Args: `title`, `loopName`, `maxIterations` optional. The invoking session is the implicit post-completion host redirect target; `execute-goal` does not expose `hostSessionId`. |
 | `loop-status` | `loop.ts` | List active/recent loops, show cumulative usage for detailed status, or restart loops with `restart`/`force` arguments |
 | `loop-cancel` | `loop.ts` | Cancel an active loop by worktree name |
 
@@ -397,6 +400,7 @@ interface ToolContext {
   input: PluginInput
   sandboxManager: SandboxManager | null
   plansRepo: PlansRepo
+  goalBriefsRepo: GoalBriefsRepo
   reviewFindingsRepo: ReviewFindingsRepo
   loopsRepo: LoopsRepo
   sectionPlansRepo: SectionPlansRepo
diff --git a/docs/tools.md b/docs/tools.md
index f6306243d..da9a97f65 100644
--- a/docs/tools.md
+++ b/docs/tools.md
@@ -13,11 +13,12 @@ See also: [Agents and Slash Commands](agents-and-commands.md), [Configuration](c
 | `plan-edit` | Edit the stored session plan by exact string replacement. | [`src/tools/plan-authoring.ts`](../src/tools/plan-authoring.ts) |
 | `section-read` | Read a section plan and status for the active loop session. | [`src/tools/section-read.ts`](../src/tools/section-read.ts) |
 | `plan-adjust` | Revise the section under audit and/or replace the remaining (not yet started) sections of the active loop plan; auditor-only, logged as a plan amendment. | [`src/tools/plan-adjust.ts`](../src/tools/plan-adjust.ts) |
+| `goal-write` | Write the session-scoped goal brief that seeds a goal loop. | [`src/tools/goal-authoring.ts`](../src/tools/goal-authoring.ts) |
 | `review-write` | Store a review finding. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `review-read` | Read review findings. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `review-delete` | Delete a review finding. | [`src/tools/review.ts`](../src/tools/review.ts) |
 | `execute-plan` | Start an iterative development loop in an isolated git worktree, or (with `mode: new-session`) launch the plan in a fresh standalone session. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
-| `execute-goal` | Start a managed goal loop in a dedicated code session inside an isolated Forge worktree. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
+| `execute-goal` | Launch a managed goal loop from the goal brief stored for the current session (`goal-write`). | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `loop-cancel` | Cancel an active loop. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `loop-status` | List loops, inspect one loop, or restart a restartable loop. | [`src/tools/loop.ts`](../src/tools/loop.ts) |
 | `launch-group` | Launch a group of features (from a PRD or a pre-split list), each planned and run as its own loop, scheduled with a concurrency cap. | [`src/tools/group.ts`](../src/tools/group.ts) |
@@ -66,6 +67,19 @@ Arguments:
 
 `plan-write` and `plan-edit` author the plan before execution; `plan-adjust` amends an already-running sectioned loop's plan during a section audit and is auditor-only.
 
+### `goal-write`
+
+Writes the session-scoped **goal brief** that seeds a goal loop, the goal-mode counterpart of `plan-write`. Available to the `goal` agent only; denied in `code`, `auditor`, `auditor-loop`, `feature-splitter`, `architect`, and `architect-auto` sessions, and inside any running loop or audit session. Denied when the session owns a running loop, the same shared guard `plan-authoring.ts` uses.
+
+Reports missing required headings as warnings, and rejects `## Phase` headings or `<!-- forge-section -->` markers without writing. A brief with heading warnings still persists so the agent can inspect the report and correct it. Accepts `append` to grow the brief incrementally. On success the brief is persisted to the session-scoped `goal_briefs` row and the tool returns a structure report with line/character counts and warnings.
+
+Arguments:
+
+| Argument | Description |
+|---|---|
+| `content` | Goal brief markdown. Must contain the required headings; must not contain `## Phase` headings or `<!-- forge-section -->` markers. |
+| `append` | Append to the existing stored brief instead of replacing it. Two newlines are inserted between the existing content and the new fragment. Creates the brief when none exists. |
+
 ## Section Tools
 
 ### `section-read`
@@ -141,22 +155,23 @@ Arguments:
 | `title` | Required short title for the session list. |
 | `plan` | Optional inline plan. If omitted, Forge reads the current session's stored plan. |
 | `loopName` | Optional loop name, slugified and uniquified. |
-| `hostSessionId` | Optional host session ID for post-completion redirect. |
 | `mode` | Execution mode. `loop` (default) runs the iterative loop in an isolated git worktree. `new-session` launches the plan in a fresh standalone session running the code agent (no worktree, no loop, not tracked by `loop-status`/`loop-cancel`). |
 
 ### `execute-goal`
 
-Starts a managed **goal loop** from free-text goal input, with no plan, decomposition, approval flow, final audit, or post-action. Forge creates a dedicated code session inside an isolated worktree and sends the goal as its initial prompt. When that coding pass goes idle, Forge replaces it with a fresh auditor session; a dirty audit then creates a fresh code session for remediation. The invoking session remains the host redirect target and is not warped into the worktree.
+Launches a managed **goal loop** from the goal brief stored for the current session (authored with `goal-write`), with no plan, decomposition, approval flow, final audit, or post-action. There is no `goal` argument — the tool reads the stored brief, refuses to launch when the brief is missing or incomplete (missing required `##` headings), and dispatches the brief as the goal. Forge creates a dedicated code session inside an isolated worktree and sends the brief as its initial prompt. When that coding pass goes idle, Forge replaces it with a fresh auditor session; a dirty audit then creates a fresh code session for remediation. The invoking session remains the host redirect target and is not warped into the worktree.
+
+The `goal` agent calls this tool directly after authoring a clean brief; the Forge execution dialog is the alternate launch surface when the user wants to pick models. `execute-goal` uses the plugin-config default execution and auditor models.
 
 Arguments:
 
 | Argument | Description |
 |---|---|
-| `goal` | Required. Non-empty free text describing the goal; the first line is used to derive a title/loop name when omitted. |
-| `title` | Optional short title for the loop (derived from the goal when omitted). |
+| `title` | Optional short title for the loop (derived from the brief's `## Goal` when omitted). |
 | `loopName` | Optional loop name, slugified and uniquified. |
 | `maxIterations` | Optional maximum loop iterations. Defaults to the plugin config `loop.defaultMaxIterations`; `0` means unlimited (run until auditor all-clear or cancellation). |
-| `hostSessionId` | Optional host session ID for post-completion redirect; defaults to the invoking (`execute-goal`) session. |
+
+The invoking session is automatically used as the post-completion host redirect target; `execute-goal` does not expose a `hostSessionId` argument.
 
 Worktree/session behavior, auditor/finding completion rule, iteration cap, and differences from `execute-plan` and `launch-group` are documented in [Loop System → Goal Loops](loop-system.md#goal-loops).
 
diff --git a/src/agents/architect-auto.ts b/src/agents/architect-auto.ts
index 3d68f8434..46178ca02 100644
--- a/src/agents/architect-auto.ts
+++ b/src/agents/architect-auto.ts
@@ -1,5 +1,6 @@
 import type { AgentDefinition } from './types'
 import { loadPrompt } from '../prompts/loader'
+import { GOAL_AUTHORING_TOOL_NAMES } from '../constants/loop'
 
 export function buildArchitectAutoAgent(promptsDir?: string): AgentDefinition {
   return {
@@ -9,7 +10,7 @@ export function buildArchitectAutoAgent(promptsDir?: string): AgentDefinition {
     mode: 'primary',
     hidden: true,
     tools: {
-      exclude: ['plan', 'plan_enter', 'plan_exit', 'question'],
+      exclude: ['plan', 'plan_enter', 'plan_exit', 'question', ...GOAL_AUTHORING_TOOL_NAMES],
     },
     systemPrompt: loadPrompt(['agents', 'architect-auto.md'], promptsDir),
   }
diff --git a/src/agents/architect.ts b/src/agents/architect.ts
index 95428d78f..937e0ead3 100644
--- a/src/agents/architect.ts
+++ b/src/agents/architect.ts
@@ -1,5 +1,6 @@
 import type { AgentDefinition } from './types'
 import { loadPrompt } from '../prompts/loader'
+import { GOAL_AUTHORING_TOOL_NAMES } from '../constants/loop'
 
 export function buildArchitectAgent(promptsDir?: string): AgentDefinition {
   return {
@@ -12,7 +13,7 @@ export function buildArchitectAgent(promptsDir?: string): AgentDefinition {
       question: 'allow',
     },
     tools: {
-      exclude: ['plan', 'plan_enter', 'plan_exit'],
+      exclude: ['plan', 'plan_enter', 'plan_exit', ...GOAL_AUTHORING_TOOL_NAMES],
     },
     systemPrompt: loadPrompt(['agents', 'architect.md'], promptsDir),
   }
diff --git a/src/agents/auditor.ts b/src/agents/auditor.ts
index 328c7ee0f..292dbe17e 100644
--- a/src/agents/auditor.ts
+++ b/src/agents/auditor.ts
@@ -1,7 +1,7 @@
 import type { AgentDefinition } from './types'
 import { loadPrompt } from '../prompts/loader'
 import { hasSectionSummaryMarkers } from '../utils/section-summary'
-import { PLAN_AUTHORING_TOOL_NAMES } from '../constants/loop'
+import { SPEC_AUTHORING_TOOL_NAMES } from '../constants/loop'
 
 const AUDITOR_TOOL_EXCLUDES = [
   'apply_patch',
@@ -17,7 +17,7 @@ const AUDITOR_TOOL_EXCLUDES = [
   'launch-group',
   'group-status',
   'group-cancel',
-  ...PLAN_AUTHORING_TOOL_NAMES,
+  ...SPEC_AUTHORING_TOOL_NAMES,
 ]
 
 function buildBasePrompt(promptsDir?: string): string {
diff --git a/src/agents/code.ts b/src/agents/code.ts
index add6afb7b..acc7241d3 100644
--- a/src/agents/code.ts
+++ b/src/agents/code.ts
@@ -1,6 +1,6 @@
 import type { AgentDefinition } from './types'
 import { loadPrompt } from '../prompts/loader'
-import { PLAN_AUTHORING_TOOL_NAMES } from '../constants/loop'
+import { SPEC_AUTHORING_TOOL_NAMES } from '../constants/loop'
 
 export function buildCodeAgent(promptsDir?: string): AgentDefinition {
   return {
@@ -13,7 +13,7 @@ export function buildCodeAgent(promptsDir?: string): AgentDefinition {
       question: 'allow',
     },
     tools: {
-      exclude: ['review-write','review-delete', 'plan', 'plan_enter', 'plan_exit', ...PLAN_AUTHORING_TOOL_NAMES]
+      exclude: ['review-write','review-delete', 'plan', 'plan_enter', 'plan_exit', ...SPEC_AUTHORING_TOOL_NAMES]
     },
     systemPrompt: loadPrompt(['agents', 'code.md'], promptsDir),
   }
diff --git a/src/agents/feature-splitter.ts b/src/agents/feature-splitter.ts
index cd27c171c..a1734205d 100644
--- a/src/agents/feature-splitter.ts
+++ b/src/agents/feature-splitter.ts
@@ -1,6 +1,6 @@
 import type { AgentDefinition } from './types'
 import { loadPrompt } from '../prompts/loader'
-import { PLAN_AUTHORING_TOOL_NAMES } from '../constants/loop'
+import { SPEC_AUTHORING_TOOL_NAMES } from '../constants/loop'
 
 export function buildFeatureSplitterAgent(promptsDir?: string): AgentDefinition {
   return {
@@ -10,7 +10,7 @@ export function buildFeatureSplitterAgent(promptsDir?: string): AgentDefinition
     mode: 'primary',
     hidden: true,
     tools: {
-      exclude: ['plan', 'plan_enter', 'plan_exit', 'question', 'write', 'edit', 'patch', ...PLAN_AUTHORING_TOOL_NAMES],
+      exclude: ['plan', 'plan_enter', 'plan_exit', 'question', 'write', 'edit', 'patch', ...SPEC_AUTHORING_TOOL_NAMES],
     },
     systemPrompt: loadPrompt(['agents', 'feature-splitter.md'], promptsDir),
   }
diff --git a/src/agents/goal.ts b/src/agents/goal.ts
new file mode 100644
index 000000000..372dcbcae
--- /dev/null
+++ b/src/agents/goal.ts
@@ -0,0 +1,26 @@
+import type { AgentDefinition } from './types'
+import { loadPrompt } from '../prompts/loader'
+import { PLAN_AUTHORING_TOOL_NAMES } from '../constants/loop'
+
+export function buildGoalAgent(promptsDir?: string): AgentDefinition {
+  return {
+    role: 'goal',
+    id: 'opencode-goal',
+    displayName: 'goal',
+    mode: 'primary',
+    permission: { question: 'allow' },
+    tools: {
+      exclude: [
+        'write', 'edit', 'multiedit', 'apply_patch', 'patch',
+        'plan', 'plan_enter', 'plan_exit',
+        'execute-plan',
+        'launch-group', 'group-status', 'group-cancel',
+        'loop-cancel', 'loop-status',
+        'review-write', 'review-delete',
+        'plan-adjust',
+        ...PLAN_AUTHORING_TOOL_NAMES,
+      ],
+    },
+    systemPrompt: loadPrompt(['agents', 'goal.md'], promptsDir),
+  }
+}
diff --git a/src/agents/index.ts b/src/agents/index.ts
index f7516edcd..1d1ce6005 100644
--- a/src/agents/index.ts
+++ b/src/agents/index.ts
@@ -4,6 +4,7 @@ import { buildArchitectAgent } from './architect'
 import { buildAuditorAgent, buildAuditorLoopAgent } from './auditor'
 import { buildArchitectAutoAgent } from './architect-auto'
 import { buildFeatureSplitterAgent } from './feature-splitter'
+import { buildGoalAgent } from './goal'
 
 export function buildAgents(promptsDir?: string): Record<AgentRole, AgentDefinition> {
   return {
@@ -13,6 +14,7 @@ export function buildAgents(promptsDir?: string): Record<AgentRole, AgentDefinit
     'auditor-loop': buildAuditorLoopAgent(promptsDir),
     'architect-auto': buildArchitectAutoAgent(promptsDir),
     'feature-splitter': buildFeatureSplitterAgent(promptsDir),
+    goal: buildGoalAgent(promptsDir),
   }
 }
 
diff --git a/src/agents/types.ts b/src/agents/types.ts
index 8db0c666c..be9badead 100644
--- a/src/agents/types.ts
+++ b/src/agents/types.ts
@@ -2,7 +2,7 @@
 /**
  * Available agent roles in the plugin.
  */
-export type AgentRole = 'code' | 'architect' | 'auditor' | 'auditor-loop' | 'architect-auto' | 'feature-splitter'
+export type AgentRole = 'code' | 'architect' | 'auditor' | 'auditor-loop' | 'architect-auto' | 'feature-splitter' | 'goal'
 
 /**
  * Definition of an agent's capabilities and configuration.
diff --git a/src/config.ts b/src/config.ts
index f749f466b..bc88a2a18 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -13,8 +13,8 @@ function buildPluginCommands(promptsDir?: string): Record<string, PluginCommand>
       template: loadPrompt(['commands','review-plan.md'], promptsDir) },
     'execute-plan': { description: 'Execute a plan in an iterative development loop, or a fresh standalone session', agent: 'code', subtask: false,
       template: loadPrompt(['commands','execute-plan.md'], promptsDir) },
-    'execute-goal': { description: 'Execute a goal in a dedicated session inside an isolated Forge worktree loop', agent: 'code', subtask: false,
-      template: loadPrompt(['commands','execute-goal.md'], promptsDir) },
+    goal: { description: 'Research a goal, ask clarifying questions, author a goal brief, and launch a goal loop', agent: 'goal', subtask: false,
+      template: loadPrompt(['commands','goal.md'], promptsDir) },
     'launch-group': { description: 'Decompose a request into features and launch them as parallel planning + development loops', agent: 'code', subtask: false,
       template: loadPrompt(['commands','launch-group.md'], promptsDir) },
     'loop-status': { description: 'Check status of all active loops', agent: 'code', subtask: false,
diff --git a/src/constants/loop.ts b/src/constants/loop.ts
index af0fe82b4..0c4009b21 100644
--- a/src/constants/loop.ts
+++ b/src/constants/loop.ts
@@ -15,6 +15,10 @@ export const MAX_TOTAL_SECTIONS = 24
  */
 export const PLAN_AUTHORING_TOOL_NAMES = ['plan-write', 'plan-edit'] as const
 
+export const GOAL_AUTHORING_TOOL_NAMES = ['goal-write'] as const
+
+export const SPEC_AUTHORING_TOOL_NAMES = [...PLAN_AUTHORING_TOOL_NAMES, ...GOAL_AUTHORING_TOOL_NAMES] as const
+
 /**
  * Resolves the full set of external directories loop/audit sessions may access: the shared temp
  * directory (always, default `/tmp/oc-forge`) plus any user-configured `loop.allowExternalDirectories`.
@@ -47,9 +51,8 @@ export interface LoopPermissionRulesetOptions {
  * layered on top. Both are added AFTER the blanket `external_directory` deny so last-match-wins
  * resolution grants access to these paths while all others stay denied.
  */
-/** Deny rules for every plan-authoring tool, derived from the shared name list. */
-function planAuthoringDenyRules(): PermissionRule[] {
-  return PLAN_AUTHORING_TOOL_NAMES.map((permission) => ({ permission, pattern: '*', action: 'deny' as const }))
+function specAuthoringDenyRules(): PermissionRule[] {
+  return SPEC_AUTHORING_TOOL_NAMES.map((permission) => ({ permission, pattern: '*', action: 'deny' as const }))
 }
 
 function buildExternalDirectoryAllowRules(allowDirectories: string[] = []): PermissionRule[] {
@@ -100,7 +103,7 @@ export function buildLoopPermissionRuleset(options: LoopPermissionRulesetOptions
     { permission: 'plan',          pattern: '*', action: 'deny' },
     { permission: 'plan_enter',    pattern: '*', action: 'deny' },
     { permission: 'plan_exit',     pattern: '*', action: 'deny' },
-    ...planAuthoringDenyRules(),
+    ...specAuthoringDenyRules(),
     { permission: 'execute-plan',  pattern: '*', action: 'deny' },
     { permission: 'execute-goal',  pattern: '*', action: 'deny' },
     { permission: 'question',      pattern: '*', action: 'deny' },
@@ -146,7 +149,7 @@ export function buildAuditSessionPermissionRuleset(options: LoopPermissionRulese
     { permission: 'plan',          pattern: '*', action: 'deny' },
     { permission: 'plan_enter',    pattern: '*', action: 'deny' },
     { permission: 'plan_exit',     pattern: '*', action: 'deny' },
-    ...planAuthoringDenyRules(),
+    ...specAuthoringDenyRules(),
     { permission: 'execute-plan',  pattern: '*', action: 'deny' },
     { permission: 'execute-goal',  pattern: '*', action: 'deny' },
     { permission: 'question',      pattern: '*', action: 'deny' },
diff --git a/src/hooks/forge-session-attach.ts b/src/hooks/forge-session-attach.ts
index 8ec8d38fa..de55181af 100644
--- a/src/hooks/forge-session-attach.ts
+++ b/src/hooks/forge-session-attach.ts
@@ -1,9 +1,10 @@
 import type { Logger } from '../types'
 import type { ForgeClient } from '../client/port'
 import type { ForgeExecutionServiceDeps, ForgeLoopExtra, PlanSource } from '../services/execution'
-import { attachLoopToSession } from '../services/execution'
+import { attachLoopToSession, resolveForgeLoopExtraSpec } from '../services/execution'
+import { resolveLoopLaunchPolicy } from '../utils/loop-helpers'
 import { resolveSandboxContextForLoop, isSandboxEnabled } from '../sandbox/context'
-import { classifyForgeWorkspace, isPendingAttachWorkspace } from '../workspace/classify-stale'
+import { classifyForgeWorkspace, isPendingAttachWorkspace, isGoalPendingAttachExpired } from '../workspace/classify-stale'
 import { removeForgeWorkspaceWithContext } from '../workspace/remove-with-context'
 import { getForgeWorkspaceLoopName } from '../workspace/forge-worktree'
 
@@ -115,7 +116,7 @@ async function attachForgeSession(
     }
 
     const cfg = (ws.extra ?? {}).forgeLoop as
-      | (Partial<ForgeLoopExtra> & { maxIterations?: number })
+      | Partial<ForgeLoopExtra>
       | undefined
 
     if (cfg?.initialPromptOwner === 'tui' && sendInitialPrompt) {
@@ -123,6 +124,24 @@ async function attachForgeSession(
       return
     }
 
+    const spec = resolveForgeLoopExtraSpec(cfg)
+    if (!spec.ok) {
+      deps.logger.log(
+        `[forge-session-attach] skip session=${sessionId} workspace=${workspaceId} loop=${loopName} reason=invalid-forgeLoop-spec error=${spec.error}`,
+      )
+      publishAttachFailureToast(
+        deps,
+        ws.directory ?? deps.directory,
+        `Forge loop "${loopName}"`,
+        'Loop launch metadata is invalid. Re-run the launch from the TUI.',
+      )
+      await removeForgeWorkspaceWithContext(
+        { client: deps.client, pendingTeardowns: deps.execDeps.pendingTeardowns, logger: deps.logger },
+        { workspaceId, loopName, action: 'remove-fully', reasonLabel: 'attach-invalid-spec' },
+      )
+      return
+    }
+
     // Build a synthetic entry for classification. If extra.projectDirectory is missing,
     // synthesize it from ws.directory so the classifier can still check the loop row.
     // This ensures the attach hook handles workspaces created by older code paths that
@@ -153,8 +172,8 @@ async function attachForgeSession(
     const isTerminalNameConflict =
       action.action === 'keep' &&
       action.reason === 'pending-start' &&
-      cfg?.initialPromptOwner === 'tui' &&
-      isPendingAttachWorkspace(classifyEntry)
+      ((cfg?.initialPromptOwner === 'tui' && isPendingAttachWorkspace(classifyEntry)) ||
+        (cfg?.kind === 'goal' && cfg?.initialPromptOwner === 'server'))
 
     if (action.action === 'keep' && action.reason !== 'running' && action.reason !== 'pending-attach' && !isTerminalNameConflict) {
       // bad config or wrong-project — toast and bail, do not attach
@@ -184,7 +203,11 @@ async function attachForgeSession(
         }
         return
       }
-      if (action.action === 'remove-fully' && cfg.initialPromptOwner === 'tui' && !isPendingAttachWorkspace(classifyEntry)) {
+      if (
+        action.action === 'remove-fully' &&
+        ((cfg.initialPromptOwner === 'tui' && !isPendingAttachWorkspace(classifyEntry)) ||
+          isGoalPendingAttachExpired(classifyEntry))
+      ) {
         await removeForgeWorkspaceWithContext(
           { client: deps.client, pendingTeardowns: deps.execDeps.pendingTeardowns, logger: deps.logger },
           { workspaceId, loopName, action: 'remove-fully', reasonLabel: 'attach-expired-pending' },
@@ -241,26 +264,33 @@ async function attachForgeSession(
       ? cfg.hostSessionId
       : sessionId
 
-    const planSource: PlanSource =
-      cfg.planSource === 'inline' && cfg.planText
-        ? { kind: 'inline', planText: cfg.planText }
-        : { kind: 'stored', sessionId: resolvedHostSessionId }
-
     let planText: string
-    if (planSource.kind === 'inline') {
-      planText = planSource.planText
+    let goalInput: { kind: 'goal'; goal: string; executorSessionId: string } | { kind: 'plan' }
+    if (spec.kind === 'goal') {
+      planText = ''
+      goalInput = { kind: 'goal', goal: spec.goal, executorSessionId: sessionId }
     } else {
-      const row = deps.execDeps.plansRepo.getForSession(sessionProjectId, planSource.sessionId)
-      if (!row) {
-        deps.logger.error(`[forge-session-attach] plan not found for session=${planSource.sessionId} loop=${loopName} workspace=${workspaceId}`)
-        publishAttachFailureToast(deps, ws.directory ?? deps.directory, `Forge loop "${loopName}"`, 'No stored plan found for this loop. Re-run "Execute → Loop" from a session that has a captured plan.')
-        await removeForgeWorkspaceWithContext(
-          { client: deps.client, pendingTeardowns: deps.execDeps.pendingTeardowns, logger: deps.logger },
-          { workspaceId, loopName, action: 'remove-fully', reasonLabel: 'attach-no-plan' },
-        )
-        return
+      goalInput = { kind: 'plan' }
+      const planSource: PlanSource =
+        cfg.planSource === 'inline' && cfg.planText
+          ? { kind: 'inline', planText: cfg.planText }
+          : { kind: 'stored', sessionId: resolvedHostSessionId }
+
+      if (planSource.kind === 'inline') {
+        planText = planSource.planText
+      } else {
+        const row = deps.execDeps.plansRepo.getForSession(sessionProjectId, planSource.sessionId)
+        if (!row) {
+          deps.logger.error(`[forge-session-attach] plan not found for session=${planSource.sessionId} loop=${loopName} workspace=${workspaceId}`)
+          publishAttachFailureToast(deps, ws.directory ?? deps.directory, `Forge loop "${loopName}"`, 'No stored plan found for this loop. Re-run "Execute → Loop" from a session that has a captured plan.')
+          await removeForgeWorkspaceWithContext(
+            { client: deps.client, pendingTeardowns: deps.execDeps.pendingTeardowns, logger: deps.logger },
+            { workspaceId, loopName, action: 'remove-fully', reasonLabel: 'attach-no-plan' },
+          )
+          return
+        }
+        planText = row.content
       }
-      planText = row.content
     }
 
     try {
@@ -281,10 +311,13 @@ async function attachForgeSession(
           auditorModel: cfg.auditorModel,
           executionVariant: cfg.executionVariant,
           auditorVariant: cfg.auditorVariant,
-          maxIterations: cfg.maxIterations ?? 50,
+          maxIterations: cfg.maxIterations ?? resolveLoopLaunchPolicy(deps.execDeps.config).maxIterations,
           sandboxEnabled: sandbox.enabled,
           sandboxContainer: sandbox.containerName,
           planText,
+          ...(goalInput.kind === 'goal'
+            ? { kind: 'goal' as const, goal: goalInput.goal, executorSessionId: goalInput.executorSessionId }
+            : {}),
           selectSession,
           selectSessionTiming: 'after-prompt',
           startWatchdog: true,
diff --git a/src/index.ts b/src/index.ts
index 9a35c3f37..3c3972f4b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,7 +4,7 @@ import type { ForgeClient, SessionGetParams } from './client/port'
 import { buildAgents } from './agents'
 import { createConfigHandler } from './config'
 import { createSessionHooks, createLoopEventHandler } from './hooks'
-import { initializeDatabase, resolveDataDir, resolveOpencodeToolOutputDir, closeDatabase, createLoopsRepo, createPlansRepo, createReviewFindingsRepo, createSectionPlansRepo, createLoopSessionUsageRepo, createFeatureGroupsRepo, createLoopTransitionsRepo, createPlanAmendmentsRepo } from './storage'
+import { initializeDatabase, resolveDataDir, resolveOpencodeToolOutputDir, closeDatabase, createLoopsRepo, createPlansRepo, createReviewFindingsRepo, createSectionPlansRepo, createLoopSessionUsageRepo, createFeatureGroupsRepo, createLoopTransitionsRepo, createPlanAmendmentsRepo, createGoalBriefsRepo } from './storage'
 import type { LoopChangeNotifier } from './loop'
 import { loadPluginConfig, resolveBundledContainerDir, resolvePromptsDir } from './setup'
 import { resolveLogPath } from './storage'
@@ -336,6 +336,7 @@ export function createForgePlugin(config: PluginConfig): Plugin {
     const featureGroupsRepo = createFeatureGroupsRepo(db)
     const loopTransitionsRepo = createLoopTransitionsRepo(db)
     const planAmendmentsRepo = createPlanAmendmentsRepo(db)
+    const goalBriefsRepo = createGoalBriefsRepo(db)
 
     // Mark any groups left in non-terminal status (extracting/planning/running) from a
     // prior process as interrupted. Do NOT auto-resume — user must restart via group-status.
@@ -635,6 +636,7 @@ export function createForgePlugin(config: PluginConfig): Plugin {
       cleanup,
       sandboxManager,
       plansRepo,
+      goalBriefsRepo,
       reviewFindingsRepo,
       loopsRepo,
       sectionPlansRepo,
diff --git a/src/loop/runtime-prompt.ts b/src/loop/runtime-prompt.ts
index 87c6b6582..a41b2ca78 100644
--- a/src/loop/runtime-prompt.ts
+++ b/src/loop/runtime-prompt.ts
@@ -53,7 +53,10 @@ export function createPromptDispatch(deps: PromptDispatchDeps): PromptDispatch {
             worktreeDir: freshState.worktreeDir,
             workspaceId: freshState.workspaceId,
             prompt: promptText,
-            ...(model ? { auditorModel: model, ...(input.variant ? { auditorVariant: input.variant } : {}) } : {}),
+            ...(model ? { auditorModel: model } : {}),
+            ...(input.variant && (model != null || (auditorModel == null && !freshState.modelFailed))
+              ? { auditorVariant: input.variant }
+              : {}),
           })
           return r.ok ? {} : { error: r.error }
         },
@@ -77,7 +80,10 @@ export function createPromptDispatch(deps: PromptDispatchDeps): PromptDispatch {
             ...(freshState.workspaceId ? { workspace: freshState.workspaceId } : {}),
             agent: 'code',
             parts: [{ type: 'text' as const, text: promptText }],
-            ...(model ? { model, ...(input.variant ? { variant: input.variant } : {}) } : {}),
+            ...(model ? { model } : {}),
+            ...(input.variant && (model != null || (effectiveModel == null && !freshState.modelFailed))
+              ? { variant: input.variant }
+              : {}),
           })
           return {}
         } catch (err) {
diff --git a/src/prompts/agents/goal.md b/src/prompts/agents/goal.md
new file mode 100644
index 000000000..1e4dfe43a
--- /dev/null
+++ b/src/prompts/agents/goal.md
@@ -0,0 +1,66 @@
+You are a goal-briefing agent. Your role is to research the codebase, ask clarifying questions inline, produce a **goal brief**, and launch a goal loop from that brief. You do not implement code, and you never produce a phased implementation plan.
+
+# Tone and style
+Be concise, direct, and to the point. Your output is displayed on a CLI using GitHub-flavored markdown.
+Minimize output tokens while maintaining quality. Do not add unnecessary preamble or postamble.
+Prioritize technical accuracy over validating assumptions. Disagree when the evidence supports it.
+
+## General guidelines
+- When exploring the codebase, prefer the Task tool with explore agents to reduce context usage and parallelize discovery.
+- Launch up to 3 explore agents IN PARALLEL when the scope is uncertain or multiple areas are involved.
+- Call multiple tools in a single response when they are independent. Batch tool calls for performance.
+- Use specialized tools (Read, Glob, Grep) instead of bash equivalents (cat, find, grep).
+
+# Following conventions
+When researching a goal, identify the existing code conventions that the implementation will need to match:
+- Check how similar code is written before letting the brief reference patterns.
+- Never assume a library or helper is available — verify it exists in the project first.
+- Note framework choices, naming conventions, and typing patterns in the brief's `## Context` section.
+
+# Code references
+When referencing code, use the pattern `file_path:line_number` for easy navigation.
+
+# File paths in the brief
+All file references in your goal brief output MUST be repo-relative paths (e.g. `src/services/auth.ts`, `test/auth.test.ts`). Never include absolute host paths (paths starting with `/` such as `/Users/...`, `/home/...`, or `/private/...`) or home-relative paths (paths starting with `~/`) in Goal, Context, Constraints, or Acceptance Criteria. The brief is replayed verbatim into code/auditor sessions that may execute inside a git worktree at a different absolute path; absolute paths from the source checkout will not resolve there. Repo-relative paths work regardless of CWD.
+
+## Constraints
+
+You are in READ-ONLY mode **for file system operations**. You must NOT directly edit source files, run destructive commands, or make code changes. You may only read, search, and analyze the codebase. Authoring the goal brief through the `goal-write` tool is expected and is not a file edit.
+
+You MUST follow a gated briefing flow:
+1. **Recon before drafting** — Inspect the codebase for what the goal touches: files and modules involved, existing helpers/patterns that already solve part of it, blast radius (callers, dependents, tests that will need updates), and any conflicting patterns that supersede the obvious approach. Do not start drafting the brief eagerly.
+2. **Clarifying questions during research** — As ambiguities surface during recon, ask the user with the `question` tool right when they arise, not batched at the end. Prefer offering concrete options with a `(Recommended)` first option over open-ended questions. Ask multiple independent questions in a single `question` call when independent. Do not ask trivial questions whose answer is obvious from the codebase or conventions; answer those yourself first.
+3. **Write the brief with `goal-write`** — Only after the goal, scope, constraints, and acceptance criteria are sufficiently clear, author the brief into storage with `goal-write`. You may call `goal-write` with `append: true` to incrementally add sections. Read the structure report that each call returns and fix any warnings (missing required headings) before finishing.
+
+## Goal Brief Storage
+
+You have access to two tools:
+
+- `goal-write`: Create, overwrite, or append (`append: true`) the goal brief stored for this session. The brief is the launch input for the goal loop.
+- `execute-goal`: Launch a goal loop from the brief stored for this session. It creates an isolated Forge worktree, prompts a new dedicated code session with the brief, and starts the watchdog, using the plugin-config default execution and auditor models.
+
+Author the brief in one or a few `goal-write` calls. Do not emit the full brief in chat — it wastes tokens and gets truncated. Read every structure report returned by `goal-write`; it lists the line/char count, missing required `##` headings, and any plan-structure violations. Fix warnings by calling `goal-write` again (overwrite) before finishing.
+
+## Goal Brief Format
+
+The brief MUST contain exactly these four `##` headings, and MUST NOT contain any others:
+- `## Goal` — What the user wants achieved and why it matters. The single, self-contained outcome statement the implementing loop will work from.
+- `## Context` — What recon found: files/modules involved, existing helpers to reuse, prior art in the codebase, and any conflicting patterns that already exist.
+- `## Constraints` — What must not change; compatibility requirements (breaking-change posture, migration ordering); and patterns to follow so the implementation matches existing conventions.
+- `## Acceptance Criteria` — Verifiable conditions that prove the goal is met. Each item must be checkable by a test, a type/lint command, or a file/behavior assertion.
+
+The brief MUST NOT contain any of the following; `goal-write` rejects them:
+- Plan section marker comments (the HTML comment the architect uses to delimit plan phases — `goal-write` rejects the brief if it contains one)
+- `## Phase` or `### Phase` headings
+- Ordered implementation steps, per-phase verification, or decomposition into phases
+
+The brief is a launch input, not a plan. It describes the destination, not the route.
+
+## After the brief is written
+
+Once `goal-write` returns a clean structure report (no missing headings, no plan-structure violations), ask the user with the `question` tool how to launch — one question, two options:
+
+- **Launch now** (Recommended) — call `execute-goal` immediately. It launches from the stored brief with the plugin-config default execution and auditor models.
+- **Open the Forge execution dialog** — the user picks the execution model, auditor model, and other launch options, then launches from the dialog. Do **not** call `execute-goal` in this path; the dialog is the launch surface.
+
+Do not ask further approval questions after the launch decision is made. Do not edit files or attempt the goal in this session — that work happens in the new dedicated session the loop creates.
diff --git a/src/prompts/commands/execute-goal.md b/src/prompts/commands/execute-goal.md
deleted file mode 100644
index c943dd51d..000000000
--- a/src/prompts/commands/execute-goal.md
+++ /dev/null
@@ -1,29 +0,0 @@
-## Step 1: Validate the Goal
-
-Resolve the goal from `$ARGUMENTS` and the surrounding conversation. The user may have already established the goal earlier in the current session, so blank, whitespace-only, or referential arguments such as "do it" do not by themselves require clarification.
-
-If you are unsure what the goal is, or if its scope is ambiguous in a way that could materially change the implementation, use the `question` tool to ask a focused clarifying question and stop until the user answers. Do not guess consequential requirements or scope. Do not ask when the goal and scope are already clear from the conversation or can be resolved through normal repository inspection.
-
-Turn the resolved goal into a self-contained implementation request. Include the relevant requirements, constraints, file or issue references, and acceptance criteria already established in the conversation, but do not invent details or include unrelated context. When newer instructions conflict with earlier ones, follow the user's latest explicit instruction.
-
-Do NOT create a plan, decompose the goal into sections, or ask for approval. The goal is implemented directly by the loop.
-
-## Step 2: Start the Goal Loop
-
-Call the `execute-goal` tool with the full, self-contained goal text:
-- goal: Required. The complete resolved goal, not necessarily the literal `$ARGUMENTS`. The new dedicated session does not inherit this conversation, so expand blank or referential arguments with the necessary context established above.
-- title: Optional short title. Derived from the goal when omitted.
-- loopName: Optional loop name. Forge slugifies it and auto-increments on collision.
-- maxIterations: Optional maximum loop iterations. Defaults to the plugin config `loop.defaultMaxIterations`.
-
-This creates an isolated Forge worktree and a new dedicated code session inside it, sends the goal as that session's initial prompt, and starts the watchdog. Docker sandboxing is used automatically when configured and available.
-
-## Step 3: You Are Done
-
-The new session implements the goal — NOT this session. Do not edit files, run builds, or attempt the goal here. Just confirm to the user that the goal loop has been launched.
-
-The loop automatically audits the work when the session goes idle and rotates in fresh code sessions until an auditor pass leaves zero open findings, which completes the loop.
-
-Use `loop-status` to inspect progress or `loop-cancel` to stop early. Both work for goal loops exactly as they do for plan loops.
-
-$ARGUMENTS
diff --git a/src/prompts/commands/goal.md b/src/prompts/commands/goal.md
new file mode 100644
index 000000000..be2fa7811
--- /dev/null
+++ b/src/prompts/commands/goal.md
@@ -0,0 +1,24 @@
+## Step 1: Resolve the Goal
+
+Resolve the goal from `$ARGUMENTS` and the surrounding conversation. The user may have already established the goal earlier in the current session, so blank, whitespace-only, or referential arguments such as "do it" do not by themselves require clarification.
+
+If you are unsure what the goal is, or if its scope is ambiguous in a way that could materially change the brief, use the `question` tool to ask a focused clarifying question and stop until the user answers. Do not guess consequential requirements or scope. Do not ask when the goal and scope are already clear from the conversation or can be resolved through normal repository inspection.
+
+## Step 2: Recon
+
+Inspect the codebase for what the goal touches: files and modules involved, existing helpers/patterns that already solve part of it, blast radius (callers, dependents, tests that will need updates), and any conflicting patterns that supersede the obvious approach. Use direct inspection (Read/Grep/Glob) and parallel explore agents for broader research. As ambiguities surface, ask clarifying questions inline with the `question` tool — not batched at the end — offering concrete options with a `(Recommended)` first option.
+
+## Step 3: Write the Goal Brief
+
+Author the brief with `goal-write`. The brief MUST contain exactly these four `##` headings and no others: `## Goal`, `## Context`, `## Constraints`, `## Acceptance Criteria`. It MUST NOT contain plan section markers, `## Phase` headings, ordered implementation steps, or per-phase verification. Read the structure report returned by each `goal-write` call and fix any warnings (missing headings) before finishing.
+
+## Step 4: Launch
+
+Once `goal-write` returns a clean structure report, launch the goal loop. Offer the user two paths with the `question` tool (one question, two options):
+
+- **Launch now** (Recommended) — call the `execute-goal` tool immediately. It reads the stored brief and starts the goal loop with the plugin-config default execution and auditor models.
+- **Open the Forge dialog** — the user picks the execution model, auditor model, and other launch options in the Forge execution dialog, then launches from there. Do **not** call `execute-goal` yourself in this path; the dialog is the launch surface.
+
+Whichever path is chosen, do not ask further approval questions after the launch decision is made.
+
+$ARGUMENTS
diff --git a/src/services/execution.ts b/src/services/execution.ts
index d56725f66..9f21dfbbe 100644
--- a/src/services/execution.ts
+++ b/src/services/execution.ts
@@ -36,6 +36,7 @@ import { loopBranchExists } from '../workspace/forge-naming'
 import { getWorktreeProjectPreconditionError } from '../workspace/forge-worktree'
 import { resolveHostSessionDirectory } from '../utils/resolve-project-root'
 import { resolvePostActionConfig, type ResolvedPostActionConfig } from '../loop/post-action-config'
+import { resolveLoopLaunchPolicy } from '../utils/loop-helpers'
 
 /**
  * A freshly created + warped loop session can transiently report "Session not
@@ -90,16 +91,44 @@ export interface ForgeLoopExtra {
   auditorModel?: string
   executionVariant?: string
   auditorVariant?: string
-  planSource: 'stored' | 'inline'
+  kind?: 'plan' | 'goal'
+  goal?: string
+  planSource?: 'stored' | 'inline'
   planText?: string
   initialPromptOwner?: 'server' | 'tui'
   pendingAttachStartedAt?: number
+  /**
+   * Maximum loop iterations as resolved at launch time by
+   * {@link resolveLoopLaunchPolicy}. Stamped on the envelope by the TUI/remote
+   * launch path so the attach hook honors the same policy without needing to
+   * re-resolve it from config (the attach hook's config view is the server's,
+   * which is consistent, but the envelope is the authority for what the
+   * launcher promised; absent stamp falls back to the server's policy).
+   */
+  maxIterations?: number
   /** Whether the loop runs sandboxed. Written by the attach hook and remote launches; read on re-attach. */
   sandboxEnabled?: boolean
   /** Docker container name when the loop runs sandboxed. */
   sandboxContainer?: string
 }
 
+export type ForgeLoopExtraSpec =
+  | { ok: true; kind: 'plan'; planText: string }
+  | { ok: true; kind: 'goal'; goal: string }
+  | { ok: false; error: string }
+
+export function resolveForgeLoopExtraSpec(
+  cfg: Partial<ForgeLoopExtra> | undefined,
+): ForgeLoopExtraSpec {
+  if (cfg?.kind === 'goal') {
+    if (typeof cfg.goal !== 'string' || cfg.goal.trim().length === 0) {
+      return { ok: false, error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank' }
+    }
+    return { ok: true, kind: 'goal', goal: cfg.goal.trim() }
+  }
+  return { ok: true, kind: 'plan', planText: cfg?.planText ?? '' }
+}
+
 export interface AttachLoopInput {
   sessionId: string
   workspaceId?: string
@@ -794,6 +823,7 @@ export async function attachLoopToSession(
             agent: 'code',
             ...workspaceParam,
             ...(model ? { model } : {}),
+            ...(executionVariant && (model != null || loopModel == null) ? { variant: executionVariant } : {}),
           })
           return {}
         } catch (err) {
@@ -1099,8 +1129,9 @@ export function createForgeExecutionService(deps: ForgeExecutionServiceDeps): Fo
     const resolvedExecutionVariant = command.executionVariant ?? deps.config.executionVariant
     const resolvedAuditorVariant = command.auditorVariant ?? deps.config.auditorVariant
     
-    // Resolve max iterations
-    const maxIterations = command.maxIterations ?? deps.config.loop?.defaultMaxIterations ?? 0
+    // Resolve max iterations from the shared launch policy so the tool and
+    // TUI/remote launch surfaces cannot diverge.
+    const maxIterations = command.maxIterations ?? resolveLoopLaunchPolicy(deps.config).maxIterations
     
     // Track created resources for rollback
     let createdSessionId: string | null = null
@@ -1346,7 +1377,7 @@ export function createForgeExecutionService(deps: ForgeExecutionServiceDeps): Fo
     const baseName = command.loopName?.trim() ? slugify(command.loopName) : slugify(title)
     const uniqueLoopName = deps.loop.generateUniqueLoopName(baseName)
 
-    const maxIterations = command.maxIterations ?? deps.config.loop?.defaultMaxIterations ?? 0
+    const maxIterations = command.maxIterations ?? resolveLoopLaunchPolicy(deps.config).maxIterations
     const resolvedExecutionModel = deps.config.executionModel
     const resolvedAuditorModel = deps.config.auditorModel
     const resolvedExecutionVariant = deps.config.executionVariant
@@ -2060,7 +2091,10 @@ export function createForgeExecutionService(deps: ForgeExecutionServiceDeps): Fo
             directory: stoppedState.worktreeDir,
             parts: [{ type: 'text' as const, text: promptText }],
             agent: promptAgent,
-            ...(model ? { model, ...(restartVariant ? { variant: restartVariant } : {}) } : {}),
+            ...(model ? { model } : {}),
+            ...(restartVariant && (model != null || loopModel == null)
+              ? { variant: restartVariant }
+              : {}),
             ...workspaceParam,
           })
           return {}
diff --git a/src/storage/index.ts b/src/storage/index.ts
index 65dd674c2..ebcac1ac9 100644
--- a/src/storage/index.ts
+++ b/src/storage/index.ts
@@ -23,3 +23,6 @@ export type { PlanRow } from './repos/plans-repo'
 
 export { createFeatureGroupsRepo } from './repos/feature-groups-repo'
 export type { FeatureGroupRow, GroupFeatureRow } from './repos/feature-groups-repo'
+
+export { createGoalBriefsRepo } from './repos/goal-briefs-repo'
+export type { GoalBriefRow } from './repos/goal-briefs-repo'
diff --git a/src/storage/migrations/144_create_goal_briefs.sql b/src/storage/migrations/144_create_goal_briefs.sql
new file mode 100644
index 000000000..1f4d44a15
--- /dev/null
+++ b/src/storage/migrations/144_create_goal_briefs.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS goal_briefs (
+  project_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  content    TEXT NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (project_id, session_id)
+);
diff --git a/src/storage/migrations/index.ts b/src/storage/migrations/index.ts
index d0e840f05..11d0c4097 100644
--- a/src/storage/migrations/index.ts
+++ b/src/storage/migrations/index.ts
@@ -399,5 +399,14 @@ export const migrations: Migration[] = [
       db.run(loadSql('143_create_plan_amendments.sql'))
     },
   },
+  {
+    id: '144',
+    description: 'Create goal_briefs table for session-scoped goal brief authoring',
+    apply: (db: Database) => {
+      const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='goal_briefs'").all()
+      if (tables.length > 0) return
+      db.run(loadSql('144_create_goal_briefs.sql'))
+    },
+  },
 
 ]
diff --git a/src/storage/repos/goal-briefs-repo.ts b/src/storage/repos/goal-briefs-repo.ts
new file mode 100644
index 000000000..874207176
--- /dev/null
+++ b/src/storage/repos/goal-briefs-repo.ts
@@ -0,0 +1,63 @@
+import type { Database } from 'bun:sqlite'
+
+export interface GoalBriefRow {
+  projectId: string
+  sessionId: string
+  content: string
+  updatedAt: number
+}
+
+export interface GoalBriefsRepo {
+  writeForSession(projectId: string, sessionId: string, content: string): void
+  getForSession(projectId: string, sessionId: string): GoalBriefRow | null
+  deleteForSession(projectId: string, sessionId: string): void
+}
+
+export function createGoalBriefsRepo(db: Database): GoalBriefsRepo {
+  type RawRow = { project_id: string; session_id: string; content: string; updated_at: number }
+
+  function mapRow(row: RawRow): GoalBriefRow {
+    return {
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      content: row.content,
+      updatedAt: row.updated_at,
+    }
+  }
+
+  const stmtWriteForSession = db.prepare(`
+    INSERT OR REPLACE INTO goal_briefs (project_id, session_id, content, updated_at)
+    VALUES (?, ?, ?, ?)
+  `)
+
+  const stmtGetForSession = db.prepare(`
+    SELECT project_id, session_id, content, updated_at
+    FROM goal_briefs
+    WHERE project_id = ? AND session_id = ?
+  `)
+
+  const stmtDeleteForSession = db.prepare(`
+    DELETE FROM goal_briefs
+    WHERE project_id = ? AND session_id = ?
+  `)
+
+  function writeForSession(projectId: string, sessionId: string, content: string): void {
+    stmtWriteForSession.run(projectId, sessionId, content, Date.now())
+  }
+
+  function getForSession(projectId: string, sessionId: string): GoalBriefRow | null {
+    const row = stmtGetForSession.get(projectId, sessionId) as RawRow | undefined
+    if (!row) return null
+    return mapRow(row)
+  }
+
+  function deleteForSession(projectId: string, sessionId: string): void {
+    stmtDeleteForSession.run(projectId, sessionId)
+  }
+
+  return {
+    writeForSession,
+    getForSession,
+    deleteForSession,
+  }
+}
diff --git a/src/tools/goal-authoring.ts b/src/tools/goal-authoring.ts
new file mode 100644
index 000000000..3c883f7f3
--- /dev/null
+++ b/src/tools/goal-authoring.ts
@@ -0,0 +1,57 @@
+import { tool } from '@opencode-ai/plugin'
+import type { ToolContext } from './types'
+import { assertWritableSession } from './session-write-guard'
+import {
+  formatGoalBriefSummary,
+  hasPlanStructureViolations,
+  summarizeGoalBrief,
+} from '../utils/goal-brief'
+
+const z = tool.schema
+
+export function createGoalAuthoringTools(ctx: ToolContext): Record<string, ReturnType<typeof tool>> {
+  return {
+    'goal-write': tool({
+      description:
+        'Create, overwrite, or append to the goal brief stored for the current session. The goal brief is the launch input for the Forge execution dialog and is authored before a loop is launched, not from inside a running loop. Phases and section markers belong in the plan, not the brief; goal-write rejects content that carries plan structure (<!-- forge-section --> markers or ## Phase headings).',
+      args: {
+        content: z
+          .string()
+          .min(1)
+          .describe('Goal brief markdown. Use ## headings for Goal, Context, Constraints, and Acceptance Criteria.'),
+        append: z
+          .boolean()
+          .optional()
+          .describe(
+            'Append to the existing stored brief instead of replacing it. Two newlines are inserted between the existing content and the new fragment. Creates the brief when none exists.',
+          ),
+      },
+      execute: async (args, context) => {
+        const guard = assertWritableSession(ctx, context.sessionID, {
+          artifactLabel: 'goal brief',
+          amendGuidance: 'Goal briefs are authored before launch, not from inside a running loop.',
+        })
+        if (guard) return guard
+
+        let next: string
+        if (args.append) {
+          const existing = ctx.goalBriefsRepo.getForSession(ctx.projectId, context.sessionID)
+          next = existing ? `${existing.content.trimEnd()}\n\n${args.content}` : args.content
+        } else {
+          next = args.content
+        }
+
+        const structure = summarizeGoalBrief(next)
+        if (hasPlanStructureViolations(structure)) {
+          return `goal-write failed: a goal brief must not contain plan structure.\n${formatGoalBriefSummary(structure)}`
+        }
+
+        ctx.goalBriefsRepo.writeForSession(ctx.projectId, context.sessionID, next)
+        ctx.logger.log(
+          `goal-write: ${args.append ? 'appended to' : 'wrote'} goal brief for session ${context.sessionID} (${next.length} chars)`,
+        )
+        return formatGoalBriefSummary(structure)
+      },
+    }),
+  }
+}
diff --git a/src/tools/index.ts b/src/tools/index.ts
index 66b02e626..f90e4aead 100644
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -2,6 +2,7 @@ import { tool } from '@opencode-ai/plugin'
 import { createReviewTools } from './review'
 import { createPlanTools } from './plan-kv'
 import { createPlanAuthoringTools } from './plan-authoring'
+import { createGoalAuthoringTools } from './goal-authoring'
 import { createLoopTools } from './loop'
 import { createGroupTools } from './group'
 import { createSectionReadTool } from './section-read'
@@ -21,6 +22,7 @@ export function createTools(ctx: ToolContext): Record<string, ReturnType<typeof
     ...createReviewTools(ctx),
     ...createPlanTools(ctx),
     ...createPlanAuthoringTools(ctx),
+    ...createGoalAuthoringTools(ctx),
     ...createLoopTools(ctx),
     ...createGroupTools(ctx),
     'section-read': createSectionReadTool(ctx),
diff --git a/src/tools/loop.ts b/src/tools/loop.ts
index f6c3aa9ea..ca1bca8f5 100644
--- a/src/tools/loop.ts
+++ b/src/tools/loop.ts
@@ -10,6 +10,7 @@ import { resolveSessionPlanOfRecord } from '../services/plan-capture'
 import { formatLoopSessionTitle, formatPlanSessionTitle } from '../utils/session-titles'
 import { getRestartability } from '../loop/restartability'
 import { loopBranchExists } from '../workspace/forge-naming'
+import { summarizeGoalBrief, formatGoalBriefSummary } from '../utils/goal-brief'
 
 const z = tool.schema
 
@@ -194,20 +195,25 @@ export function createLoopTools(ctx: ToolContext): Record<string, ReturnType<typ
     }),
 
     'execute-goal': tool({
-      description: 'Start a managed goal loop that runs in a new dedicated session: creates an isolated Forge worktree and code session, sends the goal as the initial prompt, registers the new session as the loop executor, and starts the watchdog. The invoking session remains hostSessionId and is not warped or mutated.',
+      description: 'Launch a managed goal loop from the goal brief stored for the current session with `goal-write`. Creates an isolated Forge worktree and a new dedicated code session, sends the brief as the initial prompt, registers the new session as the loop executor, and starts the watchdog. Uses plugin-config default execution/auditor models. The invoking session remains hostSessionId and is not warped or mutated.',
       args: {
-        goal: z.string().describe('The goal to execute. Non-empty free text; the first line is used to derive a title/loop name when omitted.'),
-        title: z.string().optional().describe('Short title for the loop (derived from the goal when omitted)'),
+        title: z.string().optional().describe('Short title for the loop (derived from the brief when omitted)'),
         loopName: z.string().optional().describe('Name for the loop (max 25 chars, auto-incremented if collision exists; derived from the title when omitted)'),
         maxIterations: z.number().optional().describe('Maximum loop iterations (defaults to plugin config loop.defaultMaxIterations)'),
       },
       execute: async (args, context) => {
-        const goalText = (args.goal ?? '').trim()
+        const brief = ctx.goalBriefsRepo.getForSession(ctx.projectId, context.sessionID)
+        const goalText = brief?.content?.trim() ?? ''
         if (!goalText) {
-          return 'Goal text is required. Pass a non-empty goal argument.'
+          return 'No goal brief stored for this session. Author one with the `goal-write` tool first, then call execute-goal to launch.'
         }
 
-        logger.log(`loop: starting goal loop for goal="${goalText.slice(0, 80)}"`)
+        const structure = summarizeGoalBrief(goalText)
+        if (structure.missingHeadings.length > 0 || structure.planStructureViolations.length > 0) {
+          return `execute-goal refused: the stored goal brief is incomplete.\n${formatGoalBriefSummary(structure)}\nFix the brief with another goal-write call before launching.`
+        }
+
+        logger.log(`loop: starting goal loop from stored brief (${goalText.length} chars) for session ${context.sessionID}`)
 
         const { service, execCtx } = makeService(context.sessionID)
         const result = await service.dispatch(execCtx, {
@@ -234,7 +240,7 @@ export function createLoopTools(ctx: ToolContext): Record<string, ReturnType<typ
           `Branch: ${result.data.worktreeBranch ?? 'unknown'}`,
           `Max iterations: ${maxInfo}`,
           '',
-          'A new code session has been created in the worktree with the goal as the initial prompt.',
+          'A new code session has been created in the worktree with the goal brief as the initial prompt.',
           'That session implements the goal — NOT this one. Do not edit files or attempt the goal here.',
           'Your job is done — just confirm to the user that the goal loop has been launched.',
           'The user can run loop-status or loop-cancel later if needed.',
diff --git a/src/tools/plan-authoring.ts b/src/tools/plan-authoring.ts
index 7235ce4b4..65058f7c2 100644
--- a/src/tools/plan-authoring.ts
+++ b/src/tools/plan-authoring.ts
@@ -1,28 +1,12 @@
 import { tool } from '@opencode-ai/plugin'
 import type { ToolContext } from './types'
+import { assertWritableSession } from './session-write-guard'
 import { normalizePastedPlanText } from '../utils/marked-plan-parser'
 import { writeSessionPlanContent } from '../services/plan-capture'
 import { formatPlanStructureSummary, summarizePlanStructure } from '../utils/plan-structure'
 
 const z = tool.schema
 
-/**
- * Returns an error message when the session is currently driving a running
- * loop, else null. The stored plan for a running loop is amended only via
- * `plan-adjust` during a section audit, so direct authoring from inside such a
- * session is blocked. Sessions whose loop has already terminated stay writable.
- */
-function assertWritableSession(ctx: ToolContext, sessionID: string): string | null {
-  const state = ctx.loop.service.resolveActiveLoopForSession(sessionID)
-  if (state) {
-    return (
-      `Cannot modify the plan from an active loop session (loop: ${state.loopName}). ` +
-      `The stored plan for a running loop is amended with plan-adjust during a section audit.`
-    )
-  }
-  return null
-}
-
 /**
  * Wraps `normalizePastedPlanText` and maps its reasons to user-facing messages
  * for the `plan-write` tool. Returns the normalized body on success.
@@ -75,7 +59,10 @@ export function createPlanAuthoringTools(ctx: ToolContext): Record<string, Retur
           ),
       },
       execute: async (args, context) => {
-        const guard = assertWritableSession(ctx, context.sessionID)
+        const guard = assertWritableSession(ctx, context.sessionID, {
+          artifactLabel: 'plan',
+          amendGuidance: 'The stored plan for a running loop is amended with plan-adjust during a section audit.',
+        })
         if (guard) return guard
 
         const normalized = normalizeFragment(args.content)
@@ -111,7 +98,10 @@ export function createPlanAuthoringTools(ctx: ToolContext): Record<string, Retur
           .describe('Replace every occurrence instead of requiring a unique match.'),
       },
       execute: async (args, context) => {
-        const guard = assertWritableSession(ctx, context.sessionID)
+        const guard = assertWritableSession(ctx, context.sessionID, {
+          artifactLabel: 'plan',
+          amendGuidance: 'The stored plan for a running loop is amended with plan-adjust during a section audit.',
+        })
         if (guard) return guard
 
         const existing = ctx.plansRepo.getForSession(ctx.projectId, context.sessionID)
diff --git a/src/tools/session-write-guard.ts b/src/tools/session-write-guard.ts
new file mode 100644
index 000000000..073ba8f82
--- /dev/null
+++ b/src/tools/session-write-guard.ts
@@ -0,0 +1,16 @@
+import type { ToolContext } from './types'
+
+export function assertWritableSession(
+  ctx: ToolContext,
+  sessionID: string,
+  opts: { artifactLabel: string; amendGuidance: string },
+): string | null {
+  const state = ctx.loop.service.resolveActiveLoopForSession(sessionID)
+  if (state) {
+    return (
+      `Cannot modify the ${opts.artifactLabel} from an active loop session (loop: ${state.loopName}). ` +
+      opts.amendGuidance
+    )
+  }
+  return null
+}
diff --git a/src/tools/types.ts b/src/tools/types.ts
index 816786ada..77b7caceb 100644
--- a/src/tools/types.ts
+++ b/src/tools/types.ts
@@ -8,6 +8,7 @@ import type { LoopsRepo } from '../storage/repos/loops-repo'
 import type { SectionPlansRepo } from '../storage/repos/section-plans-repo'
 import type { LoopSessionUsageRepo } from '../storage/repos/loop-session-usage-repo'
 import type { FeatureGroupsRepo } from '../storage/repos/feature-groups-repo'
+import type { GoalBriefsRepo } from '../storage/repos/goal-briefs-repo'
 import type { GroupOrchestrator } from '../services/group-orchestrator'
 import type { Loop } from '../loop'
 import type { ForgeClient } from '../client/port'
@@ -40,6 +41,7 @@ export interface ToolContext {
   sandboxManager: ReturnType<typeof createSandboxManager> | null
   /** Plans repo for plan storage. */
   plansRepo: PlansRepo
+  goalBriefsRepo: GoalBriefsRepo
   /** Review findings repo for review findings storage. */
   reviewFindingsRepo: ReviewFindingsRepo
   /** Loops repo for loop storage. */
diff --git a/src/tui.tsx b/src/tui.tsx
index 9302457c7..be21433f2 100644
--- a/src/tui.tsx
+++ b/src/tui.tsx
@@ -15,6 +15,7 @@ import { attachLoopSessionFollower, getCurrentRouteSessionId } from './tui/sessi
 import { openInBrowser, startDashboardServer, type DashboardServerHandle } from './dashboard/launch'
 import { describeDashboardBinding } from './dashboard/config'
 import { normalizePastedPlanText } from './utils/marked-plan-parser'
+import type { SessionLaunchSpec } from './utils/session-launch-spec'
 
 type TuiKeybinds = {
   executePlan: string
@@ -117,7 +118,7 @@ function ExecutionDialog(props: Omit<ExecutePlanPanelProps, 'onBack' | 'onExecut
     <box flexDirection="column" paddingX={2}>
       <box flexShrink={0} paddingBottom={1} flexDirection="row" gap={1}>
         <text fg={theme().text}>
-          <b>Execute plan</b>
+          <b>{props.spec.kind === 'goal' ? 'Execute goal' : 'Execute plan'}</b>
         </text>
       </box>
 
@@ -126,7 +127,7 @@ function ExecutionDialog(props: Omit<ExecutePlanPanelProps, 'onBack' | 'onExecut
         client={props.client}
         cache={props.cache}
         pluginConfig={props.pluginConfig}
-        planContent={props.planContent}
+        spec={props.spec}
         sessionId={props.sessionId}
         initialExecutionModel={props.initialExecutionModel}
         initialAuditorModel={props.initialAuditorModel}
@@ -145,7 +146,7 @@ function ExecutionDialog(props: Omit<ExecutePlanPanelProps, 'onBack' | 'onExecut
               client={props.client}
               cache={props.cache}
               pluginConfig={props.pluginConfig}
-              planContent={props.planContent}
+              spec={props.spec}
               sessionId={props.sessionId}
               initialExecutionModel={executionModel}
               initialAuditorModel={auditorModel}
@@ -392,7 +393,7 @@ const tui: TuiPlugin = async (api) => {
     if (connectPromise) return connectPromise
 
     setConnectionStatus('connecting')
-    connectPromise = connectForgeProject(api, directory, resolveLoopAllowedDirectories(pluginConfig), forgeDbPath).then((connected) => untrack(() => {
+    connectPromise = connectForgeProject(api, directory, resolveLoopAllowedDirectories(pluginConfig), forgeDbPath, pluginConfig, true).then((connected) => untrack(() => {
       connectPromise = null
       if (disposed) return connected
 
@@ -436,7 +437,7 @@ const tui: TuiPlugin = async (api) => {
     return startClientConnection()
   }
 
-  const openExecutionDialog = (currentClient: ForgeProjectClient, sessionID: string, planContent: string) => {
+  const openExecutionDialog = (currentClient: ForgeProjectClient, sessionID: string, spec: SessionLaunchSpec) => {
     api.ui.dialog.setSize('xlarge')
     api.ui.dialog.replace(() => (
       <ExecutionDialog
@@ -444,7 +445,7 @@ const tui: TuiPlugin = async (api) => {
         client={currentClient}
         cache={executionContextCache()}
         pluginConfig={pluginConfig}
-        planContent={planContent}
+        spec={spec}
         sessionId={sessionID}
         projectDirectory={directory}
       />
@@ -472,7 +473,7 @@ const tui: TuiPlugin = async (api) => {
             return
           }
 
-          openExecutionDialog(currentClient, sessionID, normalized.planText)
+          openExecutionDialog(currentClient, sessionID, { kind: 'plan', text: normalized.planText, updatedAt: Date.now() })
         }}
         onCancel={() => api.ui.dialog.clear()}
       />
@@ -488,10 +489,10 @@ const tui: TuiPlugin = async (api) => {
     const currentClient = await ensureClient()
     if (!currentClient) return
 
-    const planText = await currentClient.loadLatestPlan(sessionID)
-    if (!planText) {
+    const spec = await currentClient.loadLaunchSpec(sessionID)
+    if (!spec) {
       api.ui.toast({
-        message: 'No plan in current session — paste one to execute',
+        message: 'No plan or goal brief in current session — paste a plan to execute',
         variant: 'info',
         duration: 4000,
       })
@@ -499,15 +500,15 @@ const tui: TuiPlugin = async (api) => {
       return
     }
 
-    openExecutionDialog(currentClient, sessionID, planText)
+    openExecutionDialog(currentClient, sessionID, spec)
   }
 
   api.keymap.registerLayer({
     commands: [
       {
         name: 'forge.plan.execute',
-        title: 'Execute plan',
-        desc: 'Open the execution dialog for the current session plan, or paste one if none is found',
+        title: 'Execute plan or goal',
+        desc: 'Open the execution dialog for the current session plan or goal brief, or paste a plan if none is found',
         category: 'Forge',
         namespace: 'palette',
         run: () => { void runExecutePlan() },
diff --git a/src/tui/execute-plan-panel.tsx b/src/tui/execute-plan-panel.tsx
index aa8207abb..2513ece09 100644
--- a/src/tui/execute-plan-panel.tsx
+++ b/src/tui/execute-plan-panel.tsx
@@ -1,8 +1,11 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
 import { createEffect, createSignal, onCleanup, untrack } from 'solid-js'
-import { PLAN_EXECUTION_LABELS } from '../utils/plan-execution'
-import { extractPlanExecutionMetadata } from '../utils/plan-execution'
+import {
+  getLaunchModeDescription,
+  listLaunchModesForSpecKind,
+} from '../utils/plan-execution'
+import { extractLaunchSpecMetadata, type SessionLaunchSpec } from '../utils/session-launch-spec'
 import { buildDialogSelectOptions, getModelDisplayLabel, getAvailableModelVariants, getVariantDisplayLabel, normalizeVariantForModel, type ModelInfo } from '../utils/tui-models'
 import { resolveExecutionDialogDefaults } from '../utils/tui-execution-preferences'
 import { type ForgeProjectClient } from '../utils/tui-client'
@@ -29,7 +32,7 @@ export interface ExecutePlanPanelProps {
   client: ForgeProjectClient
   cache: ExecutionContextCache | null
   pluginConfig: PluginConfig
-  planContent: string
+  spec: SessionLaunchSpec
   sessionId: string
   initialExecutionModel?: string
   initialAuditorModel?: string
@@ -82,7 +85,7 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
   const [modelsLoaded, setModelsLoaded] = createSignal(!!initialSnapshot)
   const [busy, setBusy] = createSignal(false)
   const [loopName] = createSignal(
-    props.initialLoopName ?? extractPlanExecutionMetadata(untrack(() => props.planContent)).executionName,
+    props.initialLoopName ?? extractLaunchSpecMetadata(untrack(() => props.spec)).executionName,
   )
   const [target] = createSignal(props.initialTarget ?? 'local')
   const remoteNames = listRemoteNames(pluginConfig)
@@ -289,19 +292,6 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
     ))
   }
 
-  function getModeDescription(label: string): string {
-    switch (label) {
-      case 'New session':
-        return 'Create a new session and send the plan to the code agent'
-      case 'Execute here':
-        return 'Execute the plan in the current session using the code agent'
-      case 'Loop':
-        return 'Execute using iterative development loop in an isolated git worktree (Docker sandbox used automatically when available)'
-      default:
-        return ''
-    }
-  }
-
   /**
    * Shared tail for local and remote launches: surface errors, record recent
    * models, toast success, and notify the host. Returns false on error so
@@ -324,16 +314,19 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
   }
 
   async function runExecuteMode(mode: string, execModel?: string, auditModel?: string, execVariant?: string, auditVariant?: string): Promise<void> {
-    const planText = props.planContent
-    const { title } = extractPlanExecutionMetadata(planText)
+    const spec = props.spec
+    const { title } = extractLaunchSpecMetadata(spec)
 
     const normalizedMode = mode.toLowerCase()
-    const matchedLabel = PLAN_EXECUTION_LABELS.find(
+    const matchedLabel = listLaunchModesForSpecKind(spec.kind).find(
       label => normalizedMode === label.toLowerCase() || normalizedMode.startsWith(label.toLowerCase())
     ) ?? null
 
-    // Remote target: only Loop is allowed
     if (target() !== 'local') {
+      if (spec.kind === 'goal') {
+        props.api.ui.toast({ message: 'Remote targets support plans only', variant: 'error', duration: 5000 })
+        return
+      }
       if (!isModeAllowedForTarget(target(), matchedLabel ?? '')) {
         props.api.ui.toast({ message: 'Remote target supports Loop only', variant: 'error', duration: 5000 })
         return
@@ -347,7 +340,7 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
         localProjectId: props.client.projectId,
         title,
         loopName: loopName(),
-        plan: planText,
+        spec,
         executionModel: execModel,
         auditorModel: auditModel,
         executionVariant: execVariant,
@@ -384,7 +377,7 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
       mode: apiMode,
       title,
       loopName: loopName(),
-      plan: planText,
+      spec,
       executionModel: execModel,
       auditorModel: auditModel,
       executionVariant: execVariant,
@@ -423,7 +416,7 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
   return (
     <box flexDirection="column" paddingBottom={1} gap={1} minHeight={20} maxHeight="75%">
       <box paddingBottom={1}>
-        <text fg={theme().text}><b>Configure and Run Plan</b></text>
+        <text fg={theme().text}><b>{props.spec.kind === 'goal' ? 'Configure and Run Goal' : 'Configure and Run Plan'}</b></text>
       </box>
       <select
         focused={true}
@@ -454,14 +447,14 @@ export function ExecutePlanPanel(props: ExecutePlanPanelProps) {
             description: 'Press enter to edit the loop name used when launching',
             value: 'loop-name',
           },
-          ...(hasRemotes ? [{
+          ...(hasRemotes && props.spec.kind !== 'goal' ? [{
             name: `Target: ${targetLabel()}`,
             description: 'Press enter to choose where the loop runs',
             value: 'target',
           }] : []),
-          ...PLAN_EXECUTION_LABELS.map(label => ({
+          ...listLaunchModesForSpecKind(props.spec.kind).map(label => ({
             name: label,
-            description: getModeDescription(label),
+            description: getLaunchModeDescription(props.spec.kind, label),
             value: `mode:${label}`,
           })),
         ]}
diff --git a/src/utils/goal-brief.ts b/src/utils/goal-brief.ts
new file mode 100644
index 000000000..95057fd19
--- /dev/null
+++ b/src/utils/goal-brief.ts
@@ -0,0 +1,62 @@
+export const GOAL_BRIEF_REQUIRED_HEADINGS = ['Goal', 'Context', 'Constraints', 'Acceptance Criteria'] as const
+
+export interface GoalBriefStructure {
+  lines: number
+  chars: number
+  missingHeadings: string[]
+  planStructureViolations: string[]
+}
+
+const SECTION_MARKER = '<!-- forge-section -->'
+const PHASE_HEADING_REGEX = /^#{2,3}\s+Phase\b/i
+
+function hasRequiredHeading(text: string, heading: string): boolean {
+  const regex = new RegExp(`^##\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'i')
+  return text.split('\n').some((line) => regex.test(line))
+}
+
+export function summarizeGoalBrief(text: string): GoalBriefStructure {
+  const lines = text.split('\n').length
+  const chars = text.length
+
+  const missingHeadings: string[] = []
+  for (const heading of GOAL_BRIEF_REQUIRED_HEADINGS) {
+    if (!hasRequiredHeading(text, heading)) {
+      missingHeadings.push(heading)
+    }
+  }
+
+  const planStructureViolations: string[] = []
+  if (text.includes(SECTION_MARKER)) {
+    planStructureViolations.push('<!-- forge-section --> marker')
+  }
+  if (text.split('\n').some((line) => PHASE_HEADING_REGEX.test(line))) {
+    planStructureViolations.push('Phase heading')
+  }
+
+  return { lines, chars, missingHeadings, planStructureViolations }
+}
+
+export function hasPlanStructureViolations(structure: GoalBriefStructure): boolean {
+  return structure.planStructureViolations.length > 0
+}
+
+export function formatGoalBriefSummary(structure: GoalBriefStructure): string {
+  const out: string[] = [`Goal brief stored: ${structure.lines} lines, ${structure.chars} chars.`]
+
+  if (structure.missingHeadings.length > 0) {
+    out.push('Warnings:')
+    for (const heading of structure.missingHeadings) {
+      out.push(`  - Missing required section: ## ${heading}`)
+    }
+  }
+
+  if (structure.planStructureViolations.length > 0) {
+    out.push('Plan structure not allowed:')
+    for (const violation of structure.planStructureViolations) {
+      out.push(`  - ${violation}`)
+    }
+  }
+
+  return out.join('\n')
+}
diff --git a/src/utils/loop-helpers.ts b/src/utils/loop-helpers.ts
index 9f5d70a7c..68646bb8e 100644
--- a/src/utils/loop-helpers.ts
+++ b/src/utils/loop-helpers.ts
@@ -57,6 +57,29 @@ export function resolveLoopModel(
   return resolveLoopModelSelection(config, state, 'code').model
 }
 
+/**
+ * Loop launch policy derived from plugin config. This is the single resolution
+ * point for whether a loop may be provisioned and how many iterations it runs,
+ * consumed by the execute-plan/execute-goal tool handlers in {@link
+ * ../services/execution} and the TUI/remote launch surfaces in {@link
+ * ../utils/tui-client} / {@link ../utils/tui-remote-launch} (via the forgeLoop
+ * envelope read by the attach hook in {@link ../hooks/forge-session-attach}).
+ * Centralizing it keeps the tool and dialog launch paths from diverging.
+ */
+export interface LoopLaunchPolicy {
+  /** False only when `loop.enabled === false`; absence is treated as enabled. */
+  enabled: boolean
+  /** Mirrors `loop.defaultMaxIterations`. 0 means unbounded, matching the handlers. */
+  maxIterations: number
+}
+
+export function resolveLoopLaunchPolicy(config: PluginConfig | undefined): LoopLaunchPolicy {
+  return {
+    enabled: config?.loop?.enabled !== false,
+    maxIterations: config?.loop?.defaultMaxIterations ?? 0,
+  }
+}
+
 export function resolveLoopAuditorModel(
   config: PluginConfig,
   loopService: LoopService,
diff --git a/src/utils/plan-execution.ts b/src/utils/plan-execution.ts
index 4588111fe..c8bbcdab3 100644
--- a/src/utils/plan-execution.ts
+++ b/src/utils/plan-execution.ts
@@ -1,9 +1,10 @@
 /**
  * Shared plan execution utilities for TUI and tool-side approval.
- * 
+ *
  * This module provides canonical execution labels and title extraction
  * that both the TUI and plan-approval tool can import.
  */
+import type { SessionLaunchSpecKind } from './session-launch-spec'
 
 /**
  * Canonical execution mode labels used by both TUI and architect approval.
@@ -17,6 +18,30 @@ export const PLAN_EXECUTION_LABELS = [
 
 export type PlanExecutionLabel = typeof PLAN_EXECUTION_LABELS[number]
 
+export const GOAL_EXECUTION_LABELS = ['Loop'] as const
+
+export function listLaunchModesForSpecKind(kind: SessionLaunchSpecKind): readonly string[] {
+  return kind === 'goal' ? GOAL_EXECUTION_LABELS : PLAN_EXECUTION_LABELS
+}
+
+export function getLaunchModeDescription(kind: SessionLaunchSpecKind, label: string): string {
+  if (kind === 'goal') {
+    return label === 'Loop'
+      ? 'Execute the goal brief using an iterative development loop in an isolated git worktree'
+      : ''
+  }
+  switch (label) {
+    case 'New session':
+      return 'Create a new session and send the plan to the code agent'
+    case 'Execute here':
+      return 'Execute the plan in the current session using the code agent'
+    case 'Loop':
+      return 'Execute using iterative development loop in an isolated git worktree (Docker sandbox used automatically when available)'
+    default:
+      return ''
+  }
+}
+
 /**
  * Structural plan headings that should not be used as titles.
  * These are plan scaffolding headings, not actual plan titles.
@@ -42,13 +67,13 @@ const STRUCTURAL_PLAN_HEADINGS = new Set([
  * Falls back to first line if no suitable heading exists.
  * Truncates to 60 characters with ellipsis if needed.
  */
-export function extractPlanTitle(planContent: string): string {
-  return extractPlanExecutionMetadata(planContent).title
+export function extractPlanTitle(text: string): string {
+  return extractPlanExecutionMetadata(text).title
 }
 
-function extractFallbackPlanTitle(planContent: string): string {
+function extractFallbackPlanTitle(text: string): string {
   const headings: Array<{ text: string; line: number }> = []
-  const lines = planContent.split('\n')
+  const lines = text.split('\n')
   
   for (let i = 0; i < lines.length; i++) {
     const match = lines[i].match(/^#+\s+(.+)$/)
@@ -67,7 +92,7 @@ function extractFallbackPlanTitle(planContent: string): string {
   }
   
   // Try first sentence/line under Objective
-  const objectiveMatch = planContent.match(/^#+\s+Objective\s*\n+(.+)$/im)
+  const objectiveMatch = text.match(/^#+\s+Objective\s*\n+(.+)$/im)
   if (objectiveMatch?.[1]) {
     const firstLine = objectiveMatch[1].trim().split('\n')[0]
     if (firstLine) {
@@ -76,7 +101,7 @@ function extractFallbackPlanTitle(planContent: string): string {
   }
   
   // Fall back to first non-empty non-marker line
-  const firstLine = planContent.split('\n').find(line => line.trim() && !line.trim().startsWith('---'))
+  const firstLine = text.split('\n').find(line => line.trim() && !line.trim().startsWith('---'))
   if (firstLine) {
     const trimmed = firstLine.trim()
     return truncateName(trimmed, true)
@@ -113,16 +138,16 @@ export interface PlanExecutionMetadata extends LoopNameResult {
  * - `## Loop Name: approval-main-restore`
  * - `## Loop Name\n\napproval-main-restore`
  */
-function extractLoopNameFromHeading(planContent: string): string | null {
+function extractLoopNameFromHeading(text: string): string | null {
   // Try heading with inline value: ## Loop Name: value
-  const headingInlineMatch = planContent.match(/^#+\s*Loop Name:\s*(.+)$/im)
+  const headingInlineMatch = text.match(/^#+\s*Loop Name:\s*(.+)$/im)
   if (headingInlineMatch?.[1]) {
     const name = headingInlineMatch[1].trim()
     return truncateName(name)
   }
   
   // Try heading followed by value on next line: ## Loop Name\n\nvalue
-  const headingBlockMatch = planContent.match(/^#+\s*Loop Name\s*\n+\s*([^\n#]+)/im)
+  const headingBlockMatch = text.match(/^#+\s*Loop Name\s*\n+\s*([^\n#]+)/im)
   if (headingBlockMatch?.[1]) {
     const name = headingBlockMatch[1].trim()
     return truncateName(name)
@@ -131,12 +156,12 @@ function extractLoopNameFromHeading(planContent: string): string | null {
   return null
 }
 
-export function findExplicitLoopName(planContent: string): string | null {
-  const loopNameMatch = planContent.match(/^(?:\s*(?:-\s*)?)?(?:\*\*)?Loop Name(?:\*\*)?:\s*(.+)$/m)
+export function findExplicitLoopName(text: string): string | null {
+  const loopNameMatch = text.match(/^(?:\s*(?:-\s*)?)?(?:\*\*)?Loop Name(?:\*\*)?:\s*(.+)$/m)
   if (loopNameMatch?.[1]) {
     return truncateName(loopNameMatch[1].trim())
   }
-  return extractLoopNameFromHeading(planContent)
+  return extractLoopNameFromHeading(text)
 }
 
 function truncateName(name: string, ellipsis = false): string {
@@ -164,8 +189,8 @@ function truncateName(name: string, ellipsis = false): string {
  * 
  * The result is truncated to 60 characters.
  */
-export function extractLoopName(planContent: string): string {
-  return findExplicitLoopName(planContent) ?? extractFallbackPlanTitle(planContent)
+export function extractLoopName(text: string): string {
+  return findExplicitLoopName(text) ?? extractFallbackPlanTitle(text)
 }
 
 /**
@@ -177,13 +202,13 @@ export function extractLoopName(planContent: string): string {
  * 
  * This is the preferred way to get loop naming information.
  */
-export function extractLoopNames(planContent: string): LoopNameResult {
-  const { displayName, executionName } = extractPlanExecutionMetadata(planContent)
+export function extractLoopNames(text: string): LoopNameResult {
+  const { displayName, executionName } = extractPlanExecutionMetadata(text)
   return { displayName, executionName }
 }
 
-export function extractPlanExecutionMetadata(planContent: string): PlanExecutionMetadata {
-  const displayName = extractLoopName(planContent)
+export function extractPlanExecutionMetadata(text: string): PlanExecutionMetadata {
+  const displayName = extractLoopName(text)
   const executionName = sanitizeLoopName(displayName)
   return { title: truncateName(displayName, true), displayName, executionName }
 }
diff --git a/src/utils/session-launch-spec.ts b/src/utils/session-launch-spec.ts
new file mode 100644
index 000000000..3fa16b691
--- /dev/null
+++ b/src/utils/session-launch-spec.ts
@@ -0,0 +1,46 @@
+import { extractPlanExecutionMetadata, sanitizeLoopName } from './plan-execution'
+
+export type SessionLaunchSpecKind = 'plan' | 'goal'
+
+export interface SessionLaunchSpec {
+  kind: SessionLaunchSpecKind
+  text: string
+  updatedAt: number
+}
+
+const GOAL_TITLE_CAP = 80
+
+function truncateGoalTitle(line: string): string {
+  return line.length > GOAL_TITLE_CAP ? `${line.slice(0, GOAL_TITLE_CAP - 1)}…` : line
+}
+
+function deriveGoalTitle(brief: string): string {
+  const lines = brief.split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^##\s+Goal\s*$/i.test(lines[i])) continue
+    for (let j = i + 1; j < lines.length; j++) {
+      const line = lines[j].trim()
+      if (line.length === 0) continue
+      if (/^#{1,6}\s+/.test(line)) break
+      return truncateGoalTitle(line)
+    }
+    break
+  }
+  for (const raw of lines) {
+    const line = raw.trim()
+    if (line.length === 0) continue
+    if (/^#{1,6}\s+/.test(line)) continue
+    return truncateGoalTitle(line)
+  }
+  const firstLine = lines.map((l) => l.trim()).find((l) => l.length > 0) ?? brief.trim()
+  return truncateGoalTitle(firstLine)
+}
+
+export function extractLaunchSpecMetadata(spec: SessionLaunchSpec): { title: string; executionName: string } {
+  if (spec.kind === 'plan') {
+    const { title, executionName } = extractPlanExecutionMetadata(spec.text)
+    return { title, executionName }
+  }
+  const title = deriveGoalTitle(spec.text)
+  return { title, executionName: sanitizeLoopName(title) }
+}
diff --git a/src/utils/tui-client.ts b/src/utils/tui-client.ts
index bb8414a06..a60a9718b 100644
--- a/src/utils/tui-client.ts
+++ b/src/utils/tui-client.ts
@@ -14,12 +14,15 @@ import { parseModelString } from './model-fallback'
 import { listConnectedWorkspaces } from './workspace-listing'
 import { type ForgeLoopExtra } from '../services/execution'
 import { buildLoopPermissionRuleset } from '../constants/loop'
+import { resolveLoopLaunchPolicy, type LoopLaunchPolicy } from './loop-helpers'
+import type { PluginConfig } from '../types'
 import { getForgeWorkspaceLoopName, removeExistingForgeLoopWorkspaces, getWorktreeProjectPreconditionError } from '../workspace/forge-worktree'
 import { classifyWorkspaceCreateThrow } from '../workspace/workspace-create-error'
-import { fetchLoopsList, fetchStoredSessionPlan } from './tui-loop-store'
+import { fetchLoopsList, fetchStoredSessionLaunchSpec } from './tui-loop-store'
+import { extractLaunchSpecMetadata, type SessionLaunchSpec } from './session-launch-spec'
 import { decomposeDeterministically } from '../services/deterministic-decomposer'
 import { buildSectionInitialPromptText } from '../loop/prompts'
-import { extractPlanExecutionMetadata, sanitizeLoopName } from './plan-execution'
+import { sanitizeLoopName } from './plan-execution'
 import { createForgeClient } from '../client/sdk-adapter'
 import type { ForgeClient } from '../client/port'
 import { fetchLatestPlanForSession } from './plan-from-messages'
@@ -79,7 +82,7 @@ export interface ExecutePlanRequest {
   mode: ApiExecutionMode
   title: string
   loopName?: string
-  plan: string
+  spec: SessionLaunchSpec
   executionModel?: string
   auditorModel?: string
   executionVariant?: string
@@ -152,10 +155,10 @@ export interface ForgeProjectClient {
   selectSession(sessionId: string, workspaceId?: string): Promise<void>
 
   /**
-   * Read the latest marked plan from a session's chat history, or `null` when
-   * none is found. Routes through the same {@link ForgeClient} port.
+   * Read the stored plan or goal brief for a session, falling back to a marked
+   * plan in chat history, or return `null` when none is found.
    */
-  loadLatestPlan(sessionId: string): Promise<string | null>
+  loadLaunchSpec(sessionId: string): Promise<SessionLaunchSpec | null>
 
   /** Single round-trip pair: read preferences and list models. */
   loadExecutionContext(): Promise<ExecutionContext>
@@ -261,7 +264,7 @@ export interface LaunchTuiLoopOptions {
    */
   loopNameReserved?: boolean
   title: string
-  plan: string
+  spec: SessionLaunchSpec
   executionModel?: string
   auditorModel?: string
   executionVariant?: string
@@ -272,6 +275,28 @@ export interface LaunchTuiLoopOptions {
   extraWorkspaceFields?: Record<string, unknown>
   /** Merged into the forgeLoop envelope (e.g. sandboxEnabled=false for remote). */
   forgeLoopOverrides?: Partial<ForgeLoopExtra>
+  /**
+   * Plugin config used to resolve the loop launch policy (enabled flag and
+   * defaultMaxIterations). When omitted, loops are assumed enabled and
+   * defaultMaxIterations resolves to 0 (unbounded), matching the prior
+   * behaviour. The resolved maxIterations is stamped onto the forgeLoop
+   * envelope so the attach hook honours the launcher's promise instead of
+   * diverging on the server's config view.
+   */
+  pluginConfig?: PluginConfig
+  /**
+   * When true, after provisioning the workspace the launcher polls the local
+   * forge database for the loop row created by the attach hook and only
+   * reports success once it appears with a non-terminal status. Surface for
+   * local launches only: remote launches cannot observe the remote server's
+   * database, so a cross-process handshake is out of scope here and the loop
+   * row is created asynchronously in the remote plugin process.
+   */
+  awaitAttachAck?: boolean
+  /** Override the attach-acknowledgement poll timeout (ms). Default 10000. */
+  awaitAttachAckTimeoutMs?: number
+  /** Override the attach-acknowledgement poll interval (ms). Default 100. */
+  awaitAttachAckPollIntervalMs?: number
   /** Called after promptAsync succeeds; local path navigates the TUI, remote omits. */
   onLaunched?: (sessionId: string, workspaceId: string) => Promise<void>
   /** Poll interval for the workspace-connected wait. Remote launches widen this to avoid hammering the server over the network. Default 100ms. */
@@ -292,10 +317,21 @@ export async function launchTuiLoop(
     return { error: committedError }
   }
 
+  // Resolve the loop launch policy once. This is the single point that keeps
+  // the dialog and the execute-plan/execute-goal tool handlers from diverging
+  // on `loop.enabled` and `loop.defaultMaxIterations`. The attach hook reads
+  // the stamped `maxIterations` from the forgeLoop envelope (or its own
+  // server-side policy as a fallback), so the launcher's promise is honoured.
+  const policy: LoopLaunchPolicy = resolveLoopLaunchPolicy(opts.pluginConfig)
+  if (!policy.enabled) {
+    debug(`launchTuiLoop: blocked — loops disabled in plugin config`)
+    return { error: 'Loops are disabled in plugin config' }
+  }
+
   const loopName = opts.loopNameReserved
     ? opts.requestedLoopName
     : await reserveTuiLoopName(opts.client, opts.projectId, opts.requestedLoopName, opts.dbPath)
-  debug(`launchTuiLoop: inline plan (planText.length=${opts.plan.length}) hostSession=${opts.hostSessionId ?? 'none'} loop=${loopName}`)
+  debug(`launchTuiLoop: spec kind=${opts.spec.kind} text.length=${opts.spec.text.length} hostSession=${opts.hostSessionId ?? 'none'} loop=${loopName} maxIterations=${policy.maxIterations}`)
   const createdAt = Date.now()
   const forgeLoop: ForgeLoopExtra = {
     hostSessionId: opts.hostSessionId,
@@ -304,10 +340,11 @@ export async function launchTuiLoop(
     auditorModel: opts.auditorModel,
     executionVariant: opts.executionVariant,
     auditorVariant: opts.auditorVariant,
-    planSource: 'inline',
-    planText: opts.plan,
-    initialPromptOwner: 'tui',
     pendingAttachStartedAt: createdAt,
+    maxIterations: policy.maxIterations,
+    ...(opts.spec.kind === 'goal'
+      ? { kind: 'goal' as const, goal: opts.spec.text, initialPromptOwner: 'server' as const }
+      : { planSource: 'inline' as const, planText: opts.spec.text, initialPromptOwner: 'tui' as const }),
     ...opts.forgeLoopOverrides,
   }
   await removeExistingForgeLoopWorkspaces(opts.client, loopName, opts.directory, {
@@ -352,29 +389,52 @@ export async function launchTuiLoop(
       directory: workspace.directory ?? undefined,
       permission,
     })
-    const promptText = buildTuiLoopInitialPrompt(opts.plan)
 
-    const promptInput = {
-      sessionID: session.id,
-      directory: workspace.directory ?? undefined,
-      workspace: workspace.id,
-      agent: 'code' as const,
-      parts: [{ type: 'text' as const, text: promptText }],
-      ...buildPromptModelSelection(parsedModel, opts.executionVariant),
-    }
-    try {
-      await opts.client.session.promptAsync(promptInput)
-    } catch (err) {
-      debug(`launchTuiLoop: promptAsync failed session=${session.id} workspace=${workspace.id} error=${err instanceof Error ? err.message : String(err)}`)
-      await opts.client.workspace.remove({ id: workspace.id }).catch(() => undefined)
-      return { error: `Failed to send initial loop prompt: ${err instanceof Error ? err.message : String(err)}` }
+    if (opts.spec.kind === 'plan') {
+      const promptText = buildTuiLoopInitialPrompt(opts.spec.text)
+
+      const promptInput = {
+        sessionID: session.id,
+        directory: workspace.directory ?? undefined,
+        workspace: workspace.id,
+        agent: 'code' as const,
+        parts: [{ type: 'text' as const, text: promptText }],
+        ...buildPromptModelSelection(parsedModel, opts.executionVariant),
+      }
+      try {
+        await opts.client.session.promptAsync(promptInput)
+      } catch (err) {
+        debug(`launchTuiLoop: promptAsync failed session=${session.id} workspace=${workspace.id} error=${err instanceof Error ? err.message : String(err)}`)
+        await opts.client.workspace.remove({ id: workspace.id }).catch(() => undefined)
+        return { error: `Failed to send initial loop prompt: ${err instanceof Error ? err.message : String(err)}` }
+      }
+      debug(`launchTuiLoop: promptAsync ok session=${session.id} workspace=${workspace.id}`)
     }
-    debug(`launchTuiLoop: promptAsync ok session=${session.id} workspace=${workspace.id}`)
 
     await opts.onLaunched?.(session.id, workspace.id)
 
     await opts.client.workspace.syncList().catch(() => undefined)
 
+    // Local launches wait for the attach hook to acknowledge the loop row in
+    // the shared forge database before reporting success, so a workspace that
+    // never attaches (filtered session.created, attach failure, etc.) surfaces
+    // an error to the launcher instead of appearing silently launched. The
+    // remote path cannot observe the remote database, so it skips this gate.
+    if (opts.awaitAttachAck && opts.projectId && opts.dbPath) {
+      const ack = await waitForLoopRowAcknowledgement({
+        projectId: opts.projectId,
+        loopName,
+        dbPath: opts.dbPath,
+        timeoutMs: opts.awaitAttachAckTimeoutMs,
+        pollIntervalMs: opts.awaitAttachAckPollIntervalMs,
+        debug,
+      })
+      if (!ack.ok) {
+        debug(`launchTuiLoop: attach acknowledgement not observed loop=${loopName} reason=${ack.reason}`)
+        return { error: `Loop launch not confirmed by the server attach path: ${ack.reason}` }
+      }
+    }
+
     return {
       sessionId: session.id,
       loopName,
@@ -387,6 +447,54 @@ export async function launchTuiLoop(
   }
 }
 
+/**
+ * Idempotent local-launch acknowledgement: polls the shared forge database for
+ * the loop row the attach hook writes once it has wired the session into the
+ * loop runtime. Resolves once the row exists in a non-terminal status, or once
+ * the timeout elapses. Used by {@link launchTuiLoop} when the launcher opts in
+ * via `awaitAttachAck`. Remote launches cannot observe the remote database
+ * through this surface and therefore do not call it.
+ */
+async function waitForLoopRowAcknowledgement(input: {
+  projectId: string
+  loopName: string
+  dbPath: string
+  timeoutMs?: number
+  pollIntervalMs?: number
+  debug: (message: string) => void
+}): Promise<{ ok: true } | { ok: false; reason: string }> {
+  // Env overrides mirror the `FORGE_TUI_WORKSPACE_SETTLE_MS` pattern so tests
+  // can shrink the wait without adding launch-surface option plumbing.
+  const envTimeout = Number(process.env.FORGE_TUI_ATTACH_ACK_TIMEOUT_MS)
+  const envPoll = Number(process.env.FORGE_TUI_ATTACH_ACK_POLL_MS)
+  const timeoutMs = input.timeoutMs
+    ?? (Number.isFinite(envTimeout) && envTimeout >= 0 ? envTimeout : 10_000)
+  const pollIntervalMs = input.pollIntervalMs
+    ?? (Number.isFinite(envPoll) && envPoll >= 0 ? envPoll : 100)
+  const deadline = Date.now() + timeoutMs
+  do {
+    const loops = fetchLoopsList(input.projectId, input.dbPath)
+    const row = loops.find((l) => l.name === input.loopName)
+    if (row) {
+      if (row.active) {
+        input.debug(`waitForLoopRowAcknowledgement: ok loop=${input.loopName} status=running`)
+        return { ok: true }
+      }
+      // A row that exists but is not running means the attach hook wired the
+      // session and then failed/terminated it. Surface that rather than
+      // waiting out the timeout; the launcher would otherwise report a
+      // success that the server already rolled back.
+      input.debug(`waitForLoopRowAcknowledgement: terminal loop=${input.loopName} phase=${row.phase}${row.terminationReason ? ` reason=${row.terminationReason}` : ''}`)
+      return { ok: false, reason: row.terminationReason
+        ? `loop row not running (${row.phase}: ${row.terminationReason})`
+        : `loop row not running (${row.phase})` }
+    }
+    await new Promise<void>((resolve) => setTimeout(resolve, pollIntervalMs))
+  } while (Date.now() < deadline)
+  input.debug(`waitForLoopRowAcknowledgement: timeout loop=${input.loopName}`)
+  return { ok: false, reason: `loop row not observed within ${timeoutMs}ms` }
+}
+
 export async function selectTuiSession(api: TuiPluginApi, client: ForgeClient, sessionId: string, workspaceId?: string): Promise<void> {
   try {
     api.route.navigate('session', { sessionID: sessionId })
@@ -412,6 +520,14 @@ export async function connectForgeProject(
   directory?: string,
   allowExternalDirectories?: string[],
   dbPath?: string,
+  /**
+   * Plugin config used by the local launch path to resolve the loop launch
+   * policy and to wait for attach acknowledgement. Tests omit it to preserve
+   * the prior "stamp nothing / no acknowledgement" behaviour; production
+   * passes the loaded config and opts into attach acknowledgement.
+   */
+  pluginConfig?: PluginConfig,
+  awaitAttachAck?: boolean,
 ): Promise<ForgeProjectClient | null> {
   tuiDebug(`connect start directory=${directory ?? 'none'}`)
 
@@ -455,8 +571,17 @@ export async function connectForgeProject(
     async execute(sessionId, req) {
       const parsedModel = parseModelString(req.executionModel)
 
+      const spec = req.spec
+      if (!spec) {
+        return { error: 'No plan or goal spec was provided for execution.' }
+      }
+
+      if (spec.kind === 'goal' && req.mode !== 'loop') {
+        return { error: 'Goal briefs can only run as a Loop' }
+      }
+
       if (req.mode === 'execute-here') {
-        const prompt = `The architect agent has created an implementation plan in this conversation above. You are now the code agent taking over this session. Your job is to execute the plan — edit files, run commands, create tests, and implement every phase. Do NOT just describe or summarize the changes. Actually make them.\n\nPlan reference: ${req.plan}`
+        const prompt = `The architect agent has created an implementation plan in this conversation above. You are now the code agent taking over this session. Your job is to execute the plan — edit files, run commands, create tests, and implement every phase. Do NOT just describe or summarize the changes. Actually make them.\n\nPlan reference: ${spec.text}`
 
         const modelVariant = buildPromptModelSelection(parsedModel, req.executionVariant)
         try {
@@ -485,7 +610,7 @@ export async function connectForgeProject(
             directory,
             agent: 'code',
             ...modelVariant,
-            parts: [{ type: 'text' as const, text: req.plan }],
+            parts: [{ type: 'text' as const, text: spec.text }],
           })
           return { sessionId: session.id }
         } catch {
@@ -498,9 +623,9 @@ export async function connectForgeProject(
           client,
           directory,
           projectId,
-          requestedLoopName: req.loopName ?? (req.title ? sanitizeLoopName(req.title) : extractPlanExecutionMetadata(req.plan).executionName),
+          requestedLoopName: req.loopName ?? (req.title ? sanitizeLoopName(req.title) : extractLaunchSpecMetadata(spec).executionName),
           title: req.title,
-          plan: req.plan,
+          spec,
           executionModel: req.executionModel,
           auditorModel: req.auditorModel,
           executionVariant: req.executionVariant,
@@ -508,6 +633,8 @@ export async function connectForgeProject(
           hostSessionId: sessionId || undefined,
           allowDirectories: allowExternalDirectories,
           dbPath,
+          pluginConfig,
+          awaitAttachAck,
           onLaunched: (sid, wid) => selectTuiSession(api, client, sid, wid),
           debug: tuiDebug,
         })
@@ -542,15 +669,17 @@ export async function connectForgeProject(
     selectSession(sessionId, workspaceId) {
       return selectTuiSession(api, client, sessionId, workspaceId)
     },
-    loadLatestPlan(sessionId) {
+    loadLaunchSpec(sessionId) {
       // Storage is the plan of record for execute-plan and the approval hook, so
       // the dialog must show exactly what would execute. The message scan
       // remains as a fallback for sessions whose marked plan was never captured.
       // `dbPath` honors a configured PluginConfig.dataDir so tool-authored plans
       // stored outside the default data dir still resolve here.
-      const stored = projectId ? fetchStoredSessionPlan(projectId, sessionId, dbPath) : null
+      const stored = projectId ? fetchStoredSessionLaunchSpec(projectId, sessionId, dbPath) : null
       if (stored) return Promise.resolve(stored)
-      return fetchLatestPlanForSession(client, sessionId, directory)
+      return fetchLatestPlanForSession(client, sessionId, directory).then((text) =>
+        text ? { kind: 'plan', text, updatedAt: 0 } : null,
+      )
     },
     async loadExecutionContext() {
       const [sessionsResult, workspacesResult, modelsResult] = await Promise.all([
diff --git a/src/utils/tui-loop-store.ts b/src/utils/tui-loop-store.ts
index d99e0452c..66dec4c5d 100644
--- a/src/utils/tui-loop-store.ts
+++ b/src/utils/tui-loop-store.ts
@@ -10,7 +10,9 @@ import { existsSync } from 'fs'
 import { resolveForgeDbPath } from '../storage'
 import { createLoopsRepo } from '../storage/repos/loops-repo'
 import { createPlansRepo } from '../storage/repos/plans-repo'
+import { createGoalBriefsRepo } from '../storage/repos/goal-briefs-repo'
 import { createSectionPlansRepo } from '../storage/repos/section-plans-repo'
+import type { SessionLaunchSpec } from './session-launch-spec'
 import type { LoopInfo } from './tui-models'
 
 /**
@@ -95,12 +97,37 @@ export function fetchLoopsList(projectId: string, dbPathOverride?: string): Loop
   })
 }
 
-/**
- * Reads the session-scoped stored plan for the TUI execute-plan dialog.
- * Returns null when the database, row, or content is absent.
- */
-export function fetchStoredSessionPlan(projectId: string, sessionId: string, dbPathOverride?: string): string | null {
-  return withReadOnlyForgeDb(dbPathOverride, null, (db) =>
-    createPlansRepo(db).getForSession(projectId, sessionId)?.content ?? null
-  )
+export function fetchStoredSessionLaunchSpec(
+  projectId: string,
+  sessionId: string,
+  dbPathOverride?: string,
+): SessionLaunchSpec | null {
+  return withReadOnlyForgeDb(dbPathOverride, null, (db) => {
+    const planRow = createPlansRepo(db).getForSession(projectId, sessionId)
+    const hasGoalBriefsTable = db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'goal_briefs'",
+    ).get() != null
+    const goalRow = hasGoalBriefsTable
+      ? createGoalBriefsRepo(db).getForSession(projectId, sessionId)
+      : null
+
+    const planText = planRow?.content?.trim() ? planRow.content : null
+    const goalText = goalRow?.content?.trim() ? goalRow.content : null
+
+    if (planText && goalText) {
+      const planUpdatedAt = planRow!.updatedAt
+      const goalUpdatedAt = goalRow!.updatedAt
+      if (goalUpdatedAt > planUpdatedAt) {
+        return { kind: 'goal', text: goalText, updatedAt: goalUpdatedAt }
+      }
+      return { kind: 'plan', text: planText, updatedAt: planUpdatedAt }
+    }
+    if (planText) {
+      return { kind: 'plan', text: planText, updatedAt: planRow!.updatedAt }
+    }
+    if (goalText) {
+      return { kind: 'goal', text: goalText, updatedAt: goalRow!.updatedAt }
+    }
+    return null
+  })
 }
diff --git a/src/utils/tui-remote-launch.ts b/src/utils/tui-remote-launch.ts
index 21b992d5a..2a1e7b010 100644
--- a/src/utils/tui-remote-launch.ts
+++ b/src/utils/tui-remote-launch.ts
@@ -4,6 +4,7 @@ import { createRemoteForgeClient, type RemoteClientOptions } from '../client/sdk
 import type { ForgeClient } from '../client/port'
 import type { PluginConfig } from '../types'
 import { reserveTuiLoopName, launchTuiLoop } from './tui-client'
+import type { SessionLaunchSpec } from './session-launch-spec'
 
 export interface RemoteLoopRequest {
   remoteName: string
@@ -16,7 +17,7 @@ export interface RemoteLoopRequest {
   localProjectId: string
   title: string
   loopName: string
-  plan: string
+  spec: SessionLaunchSpec
   executionModel?: string
   auditorModel?: string
   executionVariant?: string
@@ -39,6 +40,8 @@ export async function executeRemoteLoop(
   req: RemoteLoopRequest,
   deps: RemoteLaunchDeps,
 ): Promise<RemoteLaunchResult> {
+  if (req.spec.kind === 'goal') return { error: 'Remote targets support plans only' }
+
   const debug = deps.debug ?? (() => {})
   const git = deps.git ?? defaultGitService
   const createClient = deps.createClient ?? createRemoteForgeClient
@@ -136,7 +139,7 @@ export async function executeRemoteLoop(
     loopNameReserved: true,
     connectPollIntervalMs: 500,
     title: req.title,
-    plan: req.plan,
+    spec: req.spec,
     executionModel: req.executionModel,
     auditorModel: req.auditorModel,
     executionVariant: req.executionVariant,
@@ -149,6 +152,7 @@ export async function executeRemoteLoop(
     forgeLoopOverrides: {
       sandboxEnabled: remote.sandbox,
     },
+    pluginConfig: deps.config,
     debug,
   })
 
diff --git a/src/workspace/classify-stale.ts b/src/workspace/classify-stale.ts
index c6df448a2..fd2ab1c1a 100644
--- a/src/workspace/classify-stale.ts
+++ b/src/workspace/classify-stale.ts
@@ -24,6 +24,16 @@ export interface ClassifyForgeWorkspaceOptions {
   pendingAttachGraceMs?: number
 }
 
+function isWithinPendingAttachGrace(
+  startedAt: unknown,
+  options: ClassifyForgeWorkspaceOptions,
+): boolean | null {
+  if (typeof startedAt !== 'number' || !Number.isFinite(startedAt)) return null
+  const nowMs = options.nowMs ?? Date.now()
+  const graceMs = options.pendingAttachGraceMs ?? PENDING_ATTACH_GRACE_MS
+  return nowMs - startedAt <= graceMs
+}
+
 export function isPendingAttachWorkspace(
   entry: ForgeWorkspaceEntry,
   options: ClassifyForgeWorkspaceOptions = {},
@@ -34,24 +44,27 @@ export function isPendingAttachWorkspace(
   const metadata = forgeLoop as { initialPromptOwner?: unknown; pendingAttachStartedAt?: unknown }
   if (metadata.initialPromptOwner !== 'tui') return false
 
-  const startedAt = metadata.pendingAttachStartedAt
-  if (typeof startedAt !== 'number' || !Number.isFinite(startedAt)) return false
+  return isWithinPendingAttachGrace(metadata.pendingAttachStartedAt, options) === true
+}
 
-  const nowMs = options.nowMs ?? Date.now()
-  const graceMs = options.pendingAttachGraceMs ?? PENDING_ATTACH_GRACE_MS
-  return nowMs - startedAt <= graceMs
+export function isGoalPendingAttachExpired(
+  entry: ForgeWorkspaceEntry,
+  options: ClassifyForgeWorkspaceOptions = {},
+): boolean {
+  const forgeLoop = entry.extra?.forgeLoop
+  if (!forgeLoop || typeof forgeLoop !== 'object') return false
+
+  const metadata = forgeLoop as { kind?: unknown; initialPromptOwner?: unknown; pendingAttachStartedAt?: unknown }
+  if (metadata.kind !== 'goal' || metadata.initialPromptOwner !== 'server') return false
+
+  return isWithinPendingAttachGrace(metadata.pendingAttachStartedAt, options) === false
 }
 
 function isPendingStartWorkspace(
   entry: ForgeWorkspaceEntry,
   options: ClassifyForgeWorkspaceOptions = {},
 ): boolean {
-  const startedAt = entry.extra?.workspaceCreatedAt
-  if (typeof startedAt !== 'number' || !Number.isFinite(startedAt)) return false
-
-  const nowMs = options.nowMs ?? Date.now()
-  const graceMs = options.pendingAttachGraceMs ?? PENDING_ATTACH_GRACE_MS
-  return nowMs - startedAt <= graceMs
+  return isWithinPendingAttachGrace(entry.extra?.workspaceCreatedAt, options) === true
 }
 
 /**
diff --git a/test/agents.test.ts b/test/agents.test.ts
index bd760d125..0ffc1073d 100644
--- a/test/agents.test.ts
+++ b/test/agents.test.ts
@@ -4,6 +4,7 @@ import { buildCodeAgent } from '../src/agents/code'
 import { buildAuditorAgent, buildAuditorLoopAgent } from '../src/agents/auditor'
 import { buildArchitectAutoAgent } from '../src/agents/architect-auto'
 import { buildFeatureSplitterAgent } from '../src/agents/feature-splitter'
+import { buildGoalAgent } from '../src/agents/goal'
 import { buildAgents } from '../src/agents'
 
 describe('Agent definitions', () => {
@@ -13,6 +14,7 @@ describe('Agent definitions', () => {
   const auditorLoopAgent = buildAuditorLoopAgent()
   const architectAutoAgent = buildArchitectAutoAgent()
   const featureSplitterAgent = buildFeatureSplitterAgent()
+  const goalAgent = buildGoalAgent()
 
   describe('metadata stability', () => {
     test('architect agent has stable metadata', () => {
@@ -166,6 +168,37 @@ describe('Agent definitions', () => {
       expect(featureSplitterAgent.tools?.exclude).toContain('plan-edit')
     })
 
+    test('goal agent has stable metadata', () => {
+      expect(goalAgent.role).toBe('goal')
+      expect(goalAgent.id).toBe('opencode-goal')
+      expect(goalAgent.displayName).toBe('goal')
+      expect(goalAgent.mode).toBe('primary')
+    })
+
+    test('goal agent excludes plan-authoring and file-mutation tools but keeps goal-write, execute-goal, and question', () => {
+      expect(goalAgent.tools?.exclude).toBeDefined()
+      expect(goalAgent.tools?.exclude).toContain('write')
+      expect(goalAgent.tools?.exclude).toContain('edit')
+      expect(goalAgent.tools?.exclude).toContain('multiedit')
+      expect(goalAgent.tools?.exclude).toContain('apply_patch')
+      expect(goalAgent.tools?.exclude).toContain('patch')
+      expect(goalAgent.tools?.exclude).toContain('plan')
+      expect(goalAgent.tools?.exclude).toContain('plan_enter')
+      expect(goalAgent.tools?.exclude).toContain('plan_exit')
+      expect(goalAgent.tools?.exclude).toContain('plan-write')
+      expect(goalAgent.tools?.exclude).toContain('plan-edit')
+      expect(goalAgent.tools?.exclude).toContain('plan-adjust')
+      expect(goalAgent.tools?.exclude).toContain('execute-plan')
+      expect(goalAgent.tools?.exclude).not.toContain('execute-goal')
+      expect(goalAgent.tools?.exclude).not.toContain('question')
+      expect(goalAgent.tools?.exclude).not.toContain('goal-write')
+    })
+
+    test('goal agent allows the question tool', () => {
+      expect(goalAgent.permission).toBeDefined()
+      expect((goalAgent.permission as Record<string, string>)?.question).toBe('allow')
+    })
+
     test('architect agents retain plan-authoring tools', () => {
       expect(architectAgent.tools?.exclude).not.toContain('plan-write')
       expect(architectAgent.tools?.exclude).not.toContain('plan-edit')
@@ -180,16 +213,37 @@ describe('Agent definitions', () => {
       expect(architectAutoAgent.systemPrompt).toContain('non-trivial implementation coupling')
     })
 
-    test('buildAgents returns all 6 agent roles', () => {
+    test('buildAgents returns all 7 agent roles', () => {
       const agents = buildAgents()
       const roles = Object.keys(agents)
-      expect(roles).toHaveLength(6)
+      expect(roles).toHaveLength(7)
       expect(roles).toContain('code')
       expect(roles).toContain('architect')
       expect(roles).toContain('auditor')
       expect(roles).toContain('auditor-loop')
       expect(roles).toContain('architect-auto')
       expect(roles).toContain('feature-splitter')
+      expect(roles).toContain('goal')
+    })
+
+    test('goal-write is excluded from every non-goal agent and kept only by the goal agent', () => {
+      const agents = buildAgents()
+      for (const [role, agent] of Object.entries(agents)) {
+        const exclude = agent.tools?.exclude ?? []
+        if (role === 'goal') {
+          expect(exclude).not.toContain('goal-write')
+        } else {
+          expect(exclude).toContain('goal-write')
+        }
+      }
+    })
+
+    test('architect and architect-auto keep plan-authoring tools but deny goal-write', () => {
+      for (const agent of [architectAgent, architectAutoAgent]) {
+        expect(agent.tools?.exclude).not.toContain('plan-write')
+        expect(agent.tools?.exclude).not.toContain('plan-edit')
+        expect(agent.tools?.exclude).toContain('goal-write')
+      }
     })
   })
 
diff --git a/test/config-commands.test.ts b/test/config-commands.test.ts
index e610603a3..3ccdab2a8 100644
--- a/test/config-commands.test.ts
+++ b/test/config-commands.test.ts
@@ -31,18 +31,13 @@ describe('createConfigHandler commands', () => {
     expect(executePlan.agent).toBe('code')
     expect(executePlan.subtask).toBe(false)
 
-    const executeGoal = commands['execute-goal']
-    expect(executeGoal).toBeDefined()
-    expect(executeGoal.template).toContain('$ARGUMENTS')
-    expect(executeGoal.template).toContain('execute-goal')
-    expect(executeGoal.template).toContain('new dedicated code session')
-    expect(executeGoal.template).toContain('surrounding conversation')
-    expect(executeGoal.template).toContain('self-contained implementation request')
-    expect(executeGoal.template).toContain('does not inherit this conversation')
-    expect(executeGoal.template).toContain('scope is ambiguous')
-    expect(executeGoal.template).toContain('`question` tool')
-    expect(executeGoal.agent).toBe('code')
-    expect(executeGoal.subtask).toBe(false)
+    const goal = commands.goal
+    expect(goal).toBeDefined()
+    expect(goal.template).toContain('$ARGUMENTS')
+    expect(goal.template).toContain('goal-write')
+    expect(goal.template).toContain('## Acceptance Criteria')
+    expect(goal.agent).toBe('goal')
+    expect(goal.subtask).toBe(false)
 
     const launchGroup = commands['launch-group']
     expect(launchGroup).toBeDefined()
diff --git a/test/config.test.ts b/test/config.test.ts
index 45c99a2e0..d84bd4e73 100644
--- a/test/config.test.ts
+++ b/test/config.test.ts
@@ -88,6 +88,7 @@ describe('createConfigHandler', () => {
         'plan',
         'plan-edit',
         'plan-write',
+        'goal-write',
         'plan_enter',
         'plan_exit',
         'question',
@@ -96,6 +97,7 @@ describe('createConfigHandler', () => {
       ].sort())
       expect(Object.keys(architectPermission).sort()).toEqual([
         'plan',
+        'goal-write',
         'plan_enter',
         'plan_exit',
         'question',
@@ -138,12 +140,28 @@ describe('createConfigHandler', () => {
       const permission = code.permission as Record<string, string>
 
       expect(permission).toBeDefined()
-      for (const tool of ['review-write', 'review-delete', 'plan', 'plan_enter', 'plan_exit', 'plan-write', 'plan-edit']) {
+      for (const tool of ['review-write', 'review-delete', 'plan', 'plan_enter', 'plan_exit', 'plan-write', 'plan-edit', 'goal-write']) {
         expect(permission[tool]).toBe('deny')
       }
       expect(permission.loop).toBeUndefined()
     })
 
+    test('architect agent excluded tools are mirrored to permission: deny, including goal-write', async () => {
+      const configHandler = createConfigHandler(agents)
+      const config: Record<string, unknown> = {}
+
+      await configHandler(config)
+
+      const agentConfigs = config.agent as Record<string, unknown>
+      const architect = agentConfigs.architect as Record<string, unknown>
+      const permission = architect.permission as Record<string, string>
+
+      expect(permission).toBeDefined()
+      expect(permission['goal-write']).toBe('deny')
+      expect(permission['plan-write']).toBeUndefined()
+      expect(permission['plan-edit']).toBeUndefined()
+    })
+
     test('user tool override cannot flip built-in permission deny', async () => {
       const configHandler = createConfigHandler(agents)
       const config: Record<string, unknown> = {
diff --git a/test/constants/loop.test.ts b/test/constants/loop.test.ts
index 0f14aed3a..ea7796af0 100644
--- a/test/constants/loop.test.ts
+++ b/test/constants/loop.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { buildLoopPermissionRuleset, buildAuditSessionPermissionRuleset, resolveLoopAllowedDirectories, MAX_TOTAL_SECTIONS, PLAN_AUTHORING_TOOL_NAMES } from '../../src/constants/loop'
+import { buildLoopPermissionRuleset, buildAuditSessionPermissionRuleset, resolveLoopAllowedDirectories, MAX_TOTAL_SECTIONS, PLAN_AUTHORING_TOOL_NAMES, GOAL_AUTHORING_TOOL_NAMES, SPEC_AUTHORING_TOOL_NAMES } from '../../src/constants/loop'
 import { resolveOpencodeToolOutputDir, DEFAULT_FORGE_TMP_DIR } from '../../src/utils/opencode-paths'
 
 const TOOL_OUTPUT_DIR = resolveOpencodeToolOutputDir()
@@ -20,6 +20,19 @@ describe('PLAN_AUTHORING_TOOL_NAMES', () => {
   })
 })
 
+describe('GOAL_AUTHORING_TOOL_NAMES', () => {
+  it('is the single list of goal-authoring tools', () => {
+    expect(GOAL_AUTHORING_TOOL_NAMES).toEqual(['goal-write'])
+  })
+})
+
+describe('SPEC_AUTHORING_TOOL_NAMES', () => {
+  it('is the plan-authoring list plus the goal-authoring list, in order', () => {
+    expect(SPEC_AUTHORING_TOOL_NAMES).toEqual(['plan-write', 'plan-edit', 'goal-write'])
+    expect(SPEC_AUTHORING_TOOL_NAMES.slice(0, PLAN_AUTHORING_TOOL_NAMES.length)).toEqual([...PLAN_AUTHORING_TOOL_NAMES])
+  })
+})
+
 describe('buildLoopPermissionRuleset', () => {
   it('emits the full loop ruleset in order (no shell-specific rules)', () => {
     const rules = buildLoopPermissionRuleset()
@@ -34,6 +47,7 @@ describe('buildLoopPermissionRuleset', () => {
       { permission: 'plan_exit', pattern: '*', action: 'deny' },
       { permission: 'plan-write', pattern: '*', action: 'deny' },
       { permission: 'plan-edit', pattern: '*', action: 'deny' },
+      { permission: 'goal-write', pattern: '*', action: 'deny' },
       { permission: 'execute-plan', pattern: '*', action: 'deny' },
       { permission: 'execute-goal', pattern: '*', action: 'deny' },
       { permission: 'question', pattern: '*', action: 'deny' },
@@ -52,6 +66,13 @@ describe('buildLoopPermissionRuleset', () => {
     expect(auditRules).toContainEqual({ permission: 'execute-goal', pattern: '*', action: 'deny' })
   })
 
+  it('denies goal-write in both loop and audit rulesets so no artifact is authored from inside a running session', () => {
+    const loopRules = buildLoopPermissionRuleset()
+    const auditRules = buildAuditSessionPermissionRuleset()
+    expect(loopRules).toContainEqual({ permission: 'goal-write', pattern: '*', action: 'deny' })
+    expect(auditRules).toContainEqual({ permission: 'goal-write', pattern: '*', action: 'deny' })
+  })
+
   it('emits no sh or bash permission rules (native bash is covered by the blanket allow)', () => {
     const rules = buildLoopPermissionRuleset()
     expect(rules.some(r => r.permission === 'sh' || r.permission === 'bash')).toBe(false)
diff --git a/test/goal-brief-launch-flow.test.ts b/test/goal-brief-launch-flow.test.ts
new file mode 100644
index 000000000..a392421ad
--- /dev/null
+++ b/test/goal-brief-launch-flow.test.ts
@@ -0,0 +1,496 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest'
+import type { Database } from 'bun:sqlite'
+import { Database as Sqlite } from 'bun:sqlite'
+import { mkdtempSync, rmSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+import { createGoalAuthoringTools } from '../src/tools/goal-authoring'
+import type { ToolContext } from '../src/tools/types'
+import { createGoalBriefsRepo } from '../src/storage/repos/goal-briefs-repo'
+import { createLoopsRepo } from '../src/storage/repos/loops-repo'
+import { createPlansRepo } from '../src/storage/repos/plans-repo'
+import { createReviewFindingsRepo } from '../src/storage/repos/review-findings-repo'
+import { createSectionPlansRepo } from '../src/storage/repos/section-plans-repo'
+import { createLoopService } from '../src/loop/service'
+import { createLoopEventHandler } from '../src/hooks/loop'
+import { createLogger } from '../src/utils/logger'
+import { connectForgeProject } from '../src/utils/tui-client'
+import { fetchStoredSessionLaunchSpec } from '../src/utils/tui-loop-store'
+import { createForgeSessionAttachHook } from '../src/hooks/forge-session-attach'
+import type { ForgeLoopExtra } from '../src/services/execution'
+import { createFakeForgeClient } from './helpers/fake-client'
+import { setupLoopsTestDb } from './helpers/loops-test-db'
+import { createPendingTeardownRegistry } from '../src/workspace/pending-teardown'
+import { createNoWaitWorkspaceStatusRegistry } from './helpers/workspace-status-registry'
+
+const PROJECT_ID = 'goal-brief-launch-project'
+const HOST_SESSION_ID = 'host-source-session'
+const TEST_DIR = '/tmp/opencode-goal-brief-launch-test-' + Date.now()
+const WS_ID = 'ws_loop'
+const SESS_ID = 'sess_new'
+const WT_DIR = '/tmp/wt/loop'
+
+const ACCEPTANCE_LINE = '- uploader retries three times before failing'
+
+function describeBrief() {
+  return `## Goal
+Ship the upload retry feature end to end.
+
+## Context
+Uploads fail silently today and users want a clear failure signal.
+
+## Constraints
+No new dependencies.
+
+## Acceptance Criteria
+${ACCEPTANCE_LINE}
+- a single retry-exhausted event is logged
+`
+}
+
+function describeBriefWithPlanStructure() {
+  return `${describeBrief()}\n## Phase 1: Setup\n- scaffold the retry module\n`
+}
+
+describe('end-to-end goal-brief launch flow', () => {
+  let db: Database
+  let tempDir: string
+  let dbPath: string
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'goal-brief-launch-test-'))
+    dbPath = join(tempDir, 'forge.db')
+    db = new Sqlite(dbPath)
+    setupLoopsTestDb(db)
+    process.env.FORGE_TUI_WORKSPACE_SETTLE_MS = '0'
+  })
+
+  afterEach(() => {
+    try { db.close() } catch {}
+    try { rmSync(tempDir, { recursive: true, force: true }) } catch {}
+    delete process.env.FORGE_TUI_WORKSPACE_SETTLE_MS
+  })
+
+  function buildRepos() {
+    return {
+      loopsRepo: createLoopsRepo(db),
+      plansRepo: createPlansRepo(db),
+      reviewFindingsRepo: createReviewFindingsRepo(db),
+      goalBriefsRepo: createGoalBriefsRepo(db),
+      sectionPlansRepo: createSectionPlansRepo(db),
+    }
+  }
+
+  function buildGoalWriteTools(repos: ReturnType<typeof buildRepos>) {
+    const loopService = createLoopService(
+      repos.loopsRepo,
+      repos.plansRepo,
+      repos.reviewFindingsRepo,
+      PROJECT_ID,
+      createLogger({ enabled: false, file: '' }),
+    )
+    const ctx = {
+      goalBriefsRepo: repos.goalBriefsRepo,
+      plansRepo: repos.plansRepo,
+      loopsRepo: repos.loopsRepo,
+      reviewFindingsRepo: repos.reviewFindingsRepo,
+      projectId: PROJECT_ID,
+      logger: createLogger({ enabled: false, file: '' }),
+      loop: { service: loopService },
+      directory: TEST_DIR,
+    } as unknown as ToolContext
+    return createGoalAuthoringTools(ctx)
+  }
+
+  function buildMockApi(createdWorkspaces: Array<Record<string, unknown>>) {
+    return {
+      client: {
+        project: {
+          list: vi.fn().mockResolvedValue({ data: [{ id: PROJECT_ID, worktree: TEST_DIR }] }),
+        },
+        experimental: {
+          workspace: {
+            list: vi.fn().mockResolvedValue({ data: createdWorkspaces }),
+            remove: vi.fn().mockResolvedValue({ data: {} }),
+            create: vi.fn().mockImplementation(async (args: any) => {
+              createdWorkspaces.push({
+                id: WS_ID,
+                type: 'forge',
+                directory: WT_DIR,
+                extra: args.extra,
+              })
+              return { data: { id: WS_ID, directory: WT_DIR, branch: null } }
+            }),
+            syncList: vi.fn().mockResolvedValue(undefined),
+            status: vi.fn().mockResolvedValue({ data: [{ workspaceID: WS_ID, status: 'connected' }] }),
+          },
+        },
+        session: {
+          create: vi.fn().mockResolvedValue({ data: { id: SESS_ID } }),
+          promptAsync: vi.fn().mockResolvedValue({ data: {} }),
+        },
+        tui: {
+          selectSession: vi.fn().mockResolvedValue(undefined),
+        },
+      },
+      route: {
+        navigate: vi.fn(),
+      },
+    }
+  }
+
+  test('brief written by goal-write resolves, launches, attaches, and surfaces in the audit prompt', async () => {
+    const repos = buildRepos()
+    const tools = buildGoalWriteTools(repos)
+
+    const writeResult = await tools['goal-write'].execute(
+      { content: describeBrief() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    expect(writeResult).toMatch(/^Goal brief stored:/)
+
+    const spec = fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)
+    expect(spec).not.toBeNull()
+    expect(spec!.kind).toBe('goal')
+    expect(spec!.text).toContain(ACCEPTANCE_LINE)
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+
+    const project = await connectForgeProject(mockApi as any, TEST_DIR, [], dbPath)
+    expect(project).not.toBeNull()
+
+    const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+      mode: 'loop',
+      title: 'Ship the upload retry feature',
+      loopName: 'upload-retry-loop',
+      spec: spec!,
+      executionModel: 'anthropic/model-a',
+      auditorModel: 'anthropic/model-b',
+      executionVariant: 'thinking-max',
+      auditorVariant: 'thinking-min',
+    })
+    if (launchResult === null || 'error' in launchResult) {
+      throw new Error(`plan.execute failed: ${launchResult === null ? 'null' : launchResult.error}`)
+    }
+
+    expect(launchResult.sessionId).toBe(SESS_ID)
+    expect(launchResult.workspaceId).toBe(WS_ID)
+    expect(launchResult.loopName).toBe('upload-retry-loop')
+
+    const createArgs = (mockApi.client.experimental.workspace.create as any).mock.calls[0][0]
+    const forgeLoop = createArgs.extra.forgeLoop as ForgeLoopExtra
+    expect(forgeLoop.kind).toBe('goal')
+    expect(forgeLoop.goal).toContain(ACCEPTANCE_LINE)
+    expect(forgeLoop.executionModel).toBe('anthropic/model-a')
+    expect(forgeLoop.auditorModel).toBe('anthropic/model-b')
+    expect(forgeLoop.initialPromptOwner).toBe('server')
+    expect(forgeLoop.planSource).toBeUndefined()
+    expect(forgeLoop.planText).toBeUndefined()
+    // No plugin config passed → policy resolves maxIterations to 0 (unbounded).
+    expect(forgeLoop.maxIterations).toBe(0)
+
+    expect((mockApi.client.session.promptAsync as any).mock.calls.length).toBe(0)
+
+    const logger = createLogger({ enabled: false, file: '' })
+    const loopService = createLoopService(
+      repos.loopsRepo,
+      repos.plansRepo,
+      repos.reviewFindingsRepo,
+      PROJECT_ID,
+      logger,
+    )
+    const loopHandler = createLoopEventHandler(
+      repos.loopsRepo,
+      repos.plansRepo,
+      repos.reviewFindingsRepo,
+      PROJECT_ID,
+      createFakeForgeClient().client,
+      logger,
+      () => ({}),
+      undefined,
+      dbPath,
+    )
+
+    const { client: hookClient, calls: hookCalls } = createFakeForgeClient({
+      workspace: {
+        list: async () => createdWorkspaces as any,
+      },
+    } as any)
+
+    const hook = createForgeSessionAttachHook({
+      client: hookClient,
+      execDeps: {
+        projectId: PROJECT_ID,
+        directory: TEST_DIR,
+        config: {},
+        logger,
+        dataDir: dbPath,
+        client: hookClient,
+        plansRepo: repos.plansRepo,
+        loopsRepo: repos.loopsRepo,
+        loopHandler,
+        loop: loopHandler.loop,
+        sandboxManager: undefined,
+        sectionPlansRepo: repos.sectionPlansRepo,
+        reviewFindingsRepo: repos.reviewFindingsRepo,
+        workspaceStatusRegistry: createNoWaitWorkspaceStatusRegistry(),
+        pendingTeardowns: createPendingTeardownRegistry(),
+      } as any,
+      projectId: PROJECT_ID,
+      directory: TEST_DIR,
+      logger,
+    })
+
+    await hook({
+      event: {
+        type: 'session.created',
+        properties: {
+          info: {
+            id: launchResult.sessionId,
+            workspaceID: launchResult.workspaceId,
+            directory: WT_DIR,
+            projectID: PROJECT_ID,
+          },
+        },
+      },
+    })
+
+    const state = loopService.getActiveState(launchResult.loopName)
+    expect(state).not.toBeNull()
+    expect(state!.kind).toBe('goal')
+    expect(state!.goal).toContain(ACCEPTANCE_LINE)
+    expect(state!.totalSections).toBe(0)
+    expect(state!.executorSessionId).toBe(launchResult.sessionId)
+    expect(state!.sessionId).toBe(launchResult.sessionId)
+    expect(repos.plansRepo.getForLoop(PROJECT_ID, launchResult.loopName)).toBeNull()
+
+    const promptCalls = hookCalls.filter((c) => c.method === 'session.promptAsync')
+    expect(promptCalls.length).toBe(1)
+    expect(promptCalls[0].params).toMatchObject({
+      sessionID: launchResult.sessionId,
+      model: { providerID: 'anthropic', modelID: 'model-a' },
+      variant: 'thinking-max',
+    })
+
+    const auditPrompt = loopService.buildAuditPrompt(state!)
+    expect(auditPrompt).toContain(ACCEPTANCE_LINE)
+  })
+
+  test('a brief carrying a Phase heading is rejected by goal-write, yields no launch spec, and cannot reach the loop launcher', async () => {
+    const repos = buildRepos()
+    const tools = buildGoalWriteTools(repos)
+
+    const writeResult = await tools['goal-write'].execute(
+      { content: describeBriefWithPlanStructure() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    expect(writeResult).toMatch(/^goal-write failed:/)
+    expect(repos.goalBriefsRepo.getForSession(PROJECT_ID, HOST_SESSION_ID)).toBeNull()
+
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)).toBeNull()
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+    const project = await connectForgeProject(mockApi as any, TEST_DIR, [], dbPath)
+    expect(project).not.toBeNull()
+
+    const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+      mode: 'loop',
+      title: 'Rejected brief',
+      loopName: 'rejected-brief-loop',
+      spec: null as unknown as { kind: 'plan'; text: string; updatedAt: number },
+    })
+    expect(launchResult).toEqual({ error: 'No plan or goal spec was provided for execution.' })
+    expect((mockApi.client.experimental.workspace.create as any).mock.calls.length).toBe(0)
+    expect((mockApi.client.session.create as any).mock.calls.length).toBe(0)
+  })
+
+  test('loop.enabled === false rejects the launch before provisioning any workspace', async () => {
+    const repos = buildRepos()
+    const tools = buildGoalWriteTools(repos)
+    await tools['goal-write'].execute(
+      { content: describeBrief() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    const spec = fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)
+    expect(spec!.kind).toBe('goal')
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+
+    const project = await connectForgeProject(
+      mockApi as any,
+      TEST_DIR,
+      [],
+      dbPath,
+      { loop: { enabled: false } } as any,
+      false,
+    )
+    expect(project).not.toBeNull()
+
+    const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+      mode: 'loop',
+      title: 'Disabled goal',
+      loopName: 'disabled-goal-loop',
+      spec: spec!,
+    })
+    expect(launchResult).toEqual({ error: 'Loops are disabled in plugin config' })
+    expect((mockApi.client.experimental.workspace.create as any).mock.calls.length).toBe(0)
+    expect((mockApi.client.session.create as any).mock.calls.length).toBe(0)
+  })
+
+  test('pluginConfig.loop.defaultMaxIterations is stamped onto the forgeLoop envelope', async () => {
+    const repos = buildRepos()
+    const tools = buildGoalWriteTools(repos)
+    await tools['goal-write'].execute(
+      { content: describeBrief() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    const spec = fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+
+    const project = await connectForgeProject(
+      mockApi as any,
+      TEST_DIR,
+      [],
+      dbPath,
+      { loop: { defaultMaxIterations: 7 } } as any,
+      false,
+    )
+    expect(project).not.toBeNull()
+
+    const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+      mode: 'loop',
+      title: 'Capped goal',
+      loopName: 'capped-goal-loop',
+      spec: spec!,
+    })
+    if (launchResult === null || 'error' in launchResult) {
+      throw new Error(`plan.execute failed: ${launchResult === null ? 'null' : launchResult.error}`)
+    }
+
+    const createArgs = (mockApi.client.experimental.workspace.create as any).mock.calls[0][0]
+    const forgeLoop = createArgs.extra.forgeLoop as ForgeLoopExtra
+    expect(forgeLoop.maxIterations).toBe(7)
+  })
+
+  test('awaitAttachAck times out when the attach hook never writes a loop row', async () => {
+    const tools = buildGoalWriteTools(buildRepos())
+    await tools['goal-write'].execute(
+      { content: describeBrief() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    const spec = fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+
+    const project = await connectForgeProject(
+      mockApi as any,
+      TEST_DIR,
+      [],
+      dbPath,
+      undefined,
+      true,
+    )
+    expect(project).not.toBeNull()
+
+    process.env.FORGE_TUI_ATTACH_ACK_TIMEOUT_MS = '200'
+    process.env.FORGE_TUI_ATTACH_ACK_POLL_MS = '50'
+    try {
+      const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+        mode: 'loop',
+        title: 'Unacked goal',
+        loopName: 'unacked-goal-loop',
+        spec: spec!,
+      })
+      expect(launchResult).not.toBeNull()
+      expect('error' in launchResult && launchResult.error).toMatch(/loop row not observed within 200ms/)
+    } finally {
+      delete process.env.FORGE_TUI_ATTACH_ACK_TIMEOUT_MS
+      delete process.env.FORGE_TUI_ATTACH_ACK_POLL_MS
+    }
+  })
+
+  test('awaitAttachAck succeeds when the attach path writes a running loop row mid-wait', async () => {
+    const repos = buildRepos()
+    const tools = buildGoalWriteTools(repos)
+    await tools['goal-write'].execute(
+      { content: describeBrief() },
+      { sessionID: HOST_SESSION_ID } as any,
+    )
+    const spec = fetchStoredSessionLaunchSpec(PROJECT_ID, HOST_SESSION_ID, dbPath)
+
+    const createdWorkspaces: Array<Record<string, unknown>> = []
+    const mockApi = buildMockApi(createdWorkspaces)
+
+    const project = await connectForgeProject(
+      mockApi as any,
+      TEST_DIR,
+      [],
+      dbPath,
+      undefined,
+      true,
+    )
+    expect(project).not.toBeNull()
+
+    process.env.FORGE_TUI_ATTACH_ACK_TIMEOUT_MS = '5000'
+    process.env.FORGE_TUI_ATTACH_ACK_POLL_MS = '20'
+    try {
+      // Simulate the server attach hook writing the loop row shortly after
+      // the workspace/session are provisioned. The poll resolves ok once the
+      // running row is visible in the shared forge database.
+      const insert = () => repos.loopsRepo.insert({
+        projectId: PROJECT_ID,
+        loopName: 'acked-goal-loop',
+        status: 'running',
+        currentSessionId: SESS_ID,
+        worktree: false,
+        worktreeDir: WT_DIR,
+        worktreeBranch: null,
+        projectDir: TEST_DIR,
+        maxIterations: 0,
+        iteration: 1,
+        auditCount: 0,
+        errorCount: 0,
+        phase: 'coding',
+        executionModel: null,
+        auditorModel: null,
+        modelFailed: false,
+        sandbox: false,
+        sandboxContainer: null,
+        startedAt: Date.now(),
+        completedAt: null,
+        terminationReason: null,
+        completionSummary: null,
+        workspaceId: WS_ID,
+        hostSessionId: HOST_SESSION_ID,
+        currentSectionIndex: 0,
+        totalSections: 0,
+        finalAuditDone: 0,
+        kind: 'goal',
+        executionVariant: null,
+        auditorVariant: null,
+      }, { lastAuditResult: null, goal: spec!.text })
+      setTimeout(insert, 30)
+
+      const launchResult = await project!.plan.execute(HOST_SESSION_ID, {
+        mode: 'loop',
+        title: 'Acked goal',
+        loopName: 'acked-goal-loop',
+        spec: spec!,
+      })
+      if (launchResult === null || 'error' in launchResult) {
+        throw new Error(`plan.execute failed: ${launchResult === null ? 'null' : launchResult.error}`)
+      }
+      expect(launchResult.loopName).toBe('acked-goal-loop')
+    } finally {
+      delete process.env.FORGE_TUI_ATTACH_ACK_TIMEOUT_MS
+      delete process.env.FORGE_TUI_ATTACH_ACK_POLL_MS
+    }
+  })
+})
diff --git a/test/goal-briefs-repo.test.ts b/test/goal-briefs-repo.test.ts
new file mode 100644
index 000000000..ec5c47259
--- /dev/null
+++ b/test/goal-briefs-repo.test.ts
@@ -0,0 +1,97 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import { Database } from 'bun:sqlite'
+import { createGoalBriefsRepo, type GoalBriefRow } from '../src/storage'
+
+function createTestDb(): Database {
+  const db = new Database(':memory:')
+  db.run(`
+    CREATE TABLE IF NOT EXISTS goal_briefs (
+      project_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      content    TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (project_id, session_id)
+    )
+  `)
+  return db
+}
+
+describe('GoalBriefsRepo', () => {
+  let db: Database
+  let repo: ReturnType<typeof createGoalBriefsRepo>
+  const projectId = 'test-project'
+
+  beforeEach(() => {
+    db = createTestDb()
+    repo = createGoalBriefsRepo(db)
+  })
+
+  afterEach(() => {
+    db.close()
+  })
+
+  test('writeForSession writes a brief readable by getForSession', () => {
+    const sessionId = 'session-123'
+    const content = 'Ship the goal-brief launch feature'
+    const now = Date.now()
+
+    repo.writeForSession(projectId, sessionId, content)
+
+    const row = repo.getForSession(projectId, sessionId)
+    expect(row).not.toBeNull()
+    expect(row?.projectId).toBe(projectId)
+    expect(row?.sessionId).toBe(sessionId)
+    expect(row?.content).toBe(content)
+    expect(typeof row?.updatedAt).toBe('number')
+    expect(row?.updatedAt).toBeGreaterThan(now - 1000)
+  })
+
+  test('getForSession returns null when no brief exists', () => {
+    const row = repo.getForSession(projectId, 'absent-session')
+    expect(row).toBeNull()
+  })
+
+  test('writeForSession overwrites an existing brief and advances updatedAt', async () => {
+    const sessionId = 'session-overwrite'
+    repo.writeForSession(projectId, sessionId, 'First brief')
+    const first = repo.getForSession(projectId, sessionId) as GoalBriefRow
+
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    repo.writeForSession(projectId, sessionId, 'Second brief')
+    const second = repo.getForSession(projectId, sessionId) as GoalBriefRow
+
+    expect(second.content).toBe('Second brief')
+    expect(second.updatedAt).toBeGreaterThan(first.updatedAt)
+
+    const count = db.prepare('SELECT COUNT(*) as count FROM goal_briefs WHERE project_id = ? AND session_id = ?').get(projectId, sessionId) as { count: number }
+    expect(count.count).toBe(1)
+  })
+
+  test('deleteForSession removes the brief', () => {
+    const sessionId = 'session-delete'
+    repo.writeForSession(projectId, sessionId, 'To be deleted')
+
+    repo.deleteForSession(projectId, sessionId)
+
+    expect(repo.getForSession(projectId, sessionId)).toBeNull()
+  })
+
+  test('deleteForSession is a no-op for an absent brief', () => {
+    expect(() => repo.deleteForSession(projectId, 'never-written')).not.toThrow()
+  })
+
+  test('rows are project-scoped: same session id under different projects is isolated', () => {
+    const sessionId = 'shared-session'
+    repo.writeForSession('project-a', sessionId, 'A brief')
+    repo.writeForSession('project-b', sessionId, 'B brief')
+
+    const a = repo.getForSession('project-a', sessionId)
+    const b = repo.getForSession('project-b', sessionId)
+    expect(a?.content).toBe('A brief')
+    expect(b?.content).toBe('B brief')
+
+    repo.deleteForSession('project-a', sessionId)
+    expect(repo.getForSession('project-a', sessionId)).toBeNull()
+    expect(repo.getForSession('project-b', sessionId)?.content).toBe('B brief')
+  })
+})
diff --git a/test/hooks/forge-session-attach.test.ts b/test/hooks/forge-session-attach.test.ts
index 3271f5c5d..9c52389b5 100644
--- a/test/hooks/forge-session-attach.test.ts
+++ b/test/hooks/forge-session-attach.test.ts
@@ -121,6 +121,89 @@ describe('createForgeSessionAttachHook', () => {
     expect(getForSessionMock).toHaveBeenCalledWith('proj_1', 'host_sess')
   })
 
+  test('maxIterations falls back to the plugin launch policy when forgeLoop.maxIterations is absent', async () => {
+    const deps = buildHookDeps({
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_forge',
+          type: 'forge',
+          directory: '/tmp/wt/forge',
+          extra: {
+            loopName: 'policy-fallback-loop',
+            projectDirectory: '/tmp/wt/forge',
+            forgeLoop: {
+              hostSessionId: 'host_sess',
+              title: 'Policy Fallback',
+              executionModel: 'prov/exec',
+              auditorModel: 'prov/aud',
+              planSource: 'stored',
+              // maxIterations intentionally omitted
+              sandboxEnabled: false,
+            },
+          },
+        },
+      ]),
+      plansRepoGetForSession: vi.fn().mockReturnValue({ content: '# Plan\n\nDo stuff.' }),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+    // Inject a server-side launch policy: defaultMaxIterations=15 must be the
+    // attach hook's fallback now that the launcher did not stamp a value.
+    ;(deps.execDeps as any).config = { loop: { defaultMaxIterations: 15 } }
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'new_sess', workspaceID: 'ws_forge' } },
+      },
+    })
+
+    expect(mockAttachLoop).toHaveBeenCalledTimes(1)
+    const [, , input] = mockAttachLoop.mock.calls[0]
+    expect(input.maxIterations).toBe(15)
+  })
+
+  test('maxIterations honours the stamped envelope value over the plugin policy', async () => {
+    const deps = buildHookDeps({
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_forge',
+          type: 'forge',
+          directory: '/tmp/wt/forge',
+          extra: {
+            loopName: 'stamped-loop',
+            projectDirectory: '/tmp/wt/forge',
+            forgeLoop: {
+              hostSessionId: 'host_sess',
+              title: 'Stamped',
+              executionModel: 'prov/exec',
+              auditorModel: 'prov/aud',
+              planSource: 'stored',
+              maxIterations: 9,
+              sandboxEnabled: false,
+            },
+          },
+        },
+      ]),
+      plansRepoGetForSession: vi.fn().mockReturnValue({ content: '# Plan\n\nDo stuff.' }),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+    ;(deps.execDeps as any).config = { loop: { defaultMaxIterations: 15 } }
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'new_sess', workspaceID: 'ws_forge' } },
+      },
+    })
+
+    const [, , input] = mockAttachLoop.mock.calls[0]
+    expect(input.maxIterations).toBe(9)
+  })
+
   test('chat.message fallback attaches TUI-created loop session without re-sending initial prompt', async () => {
     const loopsRepoGetMock = vi.fn().mockReturnValue(null)
     const deps = buildHookDeps({
@@ -1311,8 +1394,7 @@ describe('createForgeSessionAttachHook', () => {
     expect(mockAttachLoop).not.toHaveBeenCalled()
   })
 
-  test('attach hook prefers inline planText over stored plan when both are available', async () => {
-    const plansRepoGetForSession = vi.fn().mockReturnValue({ content: 'STALE_PRIOR_PLAN_TEXT' })
+  test('attach hook prefers inline planText over stored plan when both are available', async () => {    const plansRepoGetForSession = vi.fn().mockReturnValue({ content: 'STALE_PRIOR_PLAN_TEXT' })
     const deps = buildHookDeps({
       workspaceList: vi.fn().mockResolvedValue([
         {
@@ -1351,4 +1433,194 @@ describe('createForgeSessionAttachHook', () => {
 
     expect(plansRepoGetForSession).not.toHaveBeenCalled()
   })
+
+  test('goal-kind workspace is attached as a goal loop with executorSessionId = adopted session', async () => {
+    const deps = buildHookDeps({
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_goal',
+          type: 'forge',
+          directory: '/tmp/wt/goal',
+          extra: {
+            loopName: 'goal-loop',
+            projectDirectory: '/tmp/wt/goal',
+            forgeLoop: {
+              hostSessionId: 'host_sess',
+              title: 'Goal Loop',
+              kind: 'goal',
+              goal: 'ship the launch',
+              maxIterations: 30,
+              sandboxEnabled: false,
+            },
+          },
+        },
+      ]),
+      plansRepoGetForSession: vi.fn().mockReturnValue({ content: 'SHOULD_NOT_BE_USED' }),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'goal_sess', workspaceID: 'ws_goal' } },
+      },
+    })
+
+    expect(mockAttachLoop).toHaveBeenCalledTimes(1)
+    const [, , input] = mockAttachLoop.mock.calls[0]
+    expect(input.kind).toBe('goal')
+    expect(input.goal).toBe('ship the launch')
+    expect(input.executorSessionId).toBe('goal_sess')
+    expect(input.planText).toBe('')
+    const plansRepo = deps.execDeps.plansRepo.getForSession as ReturnType<typeof vi.fn>
+    expect(plansRepo).not.toHaveBeenCalled()
+  })
+
+  test('goal-kind workspace with blank goal provisions nothing and removes workspace', async () => {
+    const workspaceRemove = vi.fn().mockResolvedValue(undefined)
+    const tuiPublish = vi.fn().mockResolvedValue(undefined)
+    const deps = buildHookDeps({
+      workspaceRemove,
+      tuiPublish,
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_goal_blank',
+          type: 'forge',
+          directory: '/tmp/wt/goal-blank',
+          extra: {
+            loopName: 'goal-blank-loop',
+            projectDirectory: '/tmp/wt/goal-blank',
+            forgeLoop: {
+              title: 'Goal Blank',
+              kind: 'goal',
+              goal: '   ',
+            },
+          },
+        },
+      ]),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'goal_blank_sess', workspaceID: 'ws_goal_blank' } },
+      },
+    })
+
+    expect(mockAttachLoop).not.toHaveBeenCalled()
+    expect(workspaceRemove).toHaveBeenCalledWith({ id: 'ws_goal_blank' })
+    expect(deps.execDeps.pendingTeardowns.set).toHaveBeenCalledWith(
+      'goal-blank-loop',
+      expect.objectContaining({ doRemoveWorktree: true, doCommit: false }),
+    )
+    expect(tuiPublish).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({
+        properties: expect.objectContaining({ variant: 'error' }),
+      }),
+    }))
+  })
+
+  test('goal-kind workspace with non-string goal provisions nothing and removes workspace without throwing', async () => {
+    const workspaceRemove = vi.fn().mockResolvedValue(undefined)
+    const tuiPublish = vi.fn().mockResolvedValue(undefined)
+    const deps = buildHookDeps({
+      workspaceRemove,
+      tuiPublish,
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_goal_malformed',
+          type: 'forge',
+          directory: '/tmp/wt/goal-malformed',
+          extra: {
+            loopName: 'goal-malformed-loop',
+            projectDirectory: '/tmp/wt/goal-malformed',
+            forgeLoop: {
+              title: 'Goal Malformed',
+              kind: 'goal',
+              goal: 42,
+            },
+          },
+        },
+      ]),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await expect(handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'goal_malformed_sess', workspaceID: 'ws_goal_malformed' } },
+      },
+    })).resolves.toBeUndefined()
+
+    expect(mockAttachLoop).not.toHaveBeenCalled()
+    expect(workspaceRemove).toHaveBeenCalledWith({ id: 'ws_goal_malformed' })
+    expect(deps.execDeps.pendingTeardowns.set).toHaveBeenCalledWith(
+      'goal-malformed-loop',
+      expect.objectContaining({ doRemoveWorktree: true, doCommit: false }),
+    )
+    expect(tuiPublish).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({
+        properties: expect.objectContaining({ variant: 'error' }),
+      }),
+    }))
+  })
+
+  test('expired server-owned goal workspace with no loop row is removed and never attaches', async () => {
+    const workspaceRemove = vi.fn().mockResolvedValue(undefined)
+    const tuiPublish = vi.fn().mockResolvedValue(undefined)
+    const deps = buildHookDeps({
+      workspaceRemove,
+      tuiPublish,
+      workspaceList: vi.fn().mockResolvedValue([
+        {
+          id: 'ws_goal_expired',
+          type: 'forge',
+          directory: '/tmp/wt/goal-expired',
+          extra: {
+            loopName: 'goal-expired-loop',
+            projectDirectory: '/tmp/wt/goal-expired',
+            workspaceCreatedAt: Date.now() - (10 * 60 * 1000),
+            forgeLoop: {
+              title: 'Goal Expired',
+              kind: 'goal',
+              goal: 'ship the long-abandoned thing',
+              initialPromptOwner: 'server',
+              pendingAttachStartedAt: Date.now() - (10 * 60 * 1000),
+            },
+          },
+        },
+      ]),
+      loopsRepoGet: vi.fn().mockReturnValue(null),
+    })
+
+    const handler = createForgeSessionAttachHook(deps as any)
+
+    await handler({
+      event: {
+        type: 'session.created',
+        properties: { info: { id: 'goal_expired_sess', workspaceID: 'ws_goal_expired' } },
+      },
+    })
+
+    expect(mockAttachLoop).not.toHaveBeenCalled()
+    expect(workspaceRemove).toHaveBeenCalledWith({ id: 'ws_goal_expired' })
+    expect(deps.execDeps.pendingTeardowns.set).toHaveBeenCalledWith(
+      'goal-expired-loop',
+      expect.objectContaining({ doRemoveWorktree: true, doCommit: false }),
+    )
+    expect(tuiPublish).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({
+        properties: expect.objectContaining({
+          message: expect.stringContaining('attach window expired'),
+        }),
+      }),
+    }))
+  })
 })
diff --git a/test/loop-helpers.test.ts b/test/loop-helpers.test.ts
index e4a950858..ffc62f5b1 100644
--- a/test/loop-helpers.test.ts
+++ b/test/loop-helpers.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { resolveLoopModel, resolveLoopAuditorModel, formatDuration, computeElapsedSeconds } from '../src/utils/loop-helpers'
+import { resolveLoopModel, resolveLoopAuditorModel, resolveLoopLaunchPolicy, formatDuration, computeElapsedSeconds } from '../src/utils/loop-helpers'
 import type { PluginConfig } from '../src/types'
 
 describe('resolveLoopModel', () => {
@@ -143,6 +143,29 @@ describe('resolveLoopAuditorModel', () => {
   })
 })
 
+describe('resolveLoopLaunchPolicy', () => {
+  it('defaults to enabled=true and maxIterations=0 when config is absent', () => {
+    expect(resolveLoopLaunchPolicy(undefined)).toEqual({ enabled: true, maxIterations: 0 })
+  })
+
+  it('keeps defaults when loop config is present but unset', () => {
+    expect(resolveLoopLaunchPolicy({ loop: {} } as PluginConfig)).toEqual({ enabled: true, maxIterations: 0 })
+  })
+
+  it('reads loop.enabled === false as disabled', () => {
+    expect(resolveLoopLaunchPolicy({ loop: { enabled: false } } as PluginConfig)).toEqual({ enabled: false, maxIterations: 0 })
+  })
+
+  it('reads loop.defaultMaxIterations', () => {
+    expect(resolveLoopLaunchPolicy({ loop: { defaultMaxIterations: 15 } } as PluginConfig)).toEqual({ enabled: true, maxIterations: 15 })
+  })
+
+  it('does not treat enabled: true as disabling defaultMaxIterations', () => {
+    expect(resolveLoopLaunchPolicy({ loop: { enabled: true, defaultMaxIterations: 7 } } as PluginConfig)).toEqual({ enabled: true, maxIterations: 7 })
+  })
+})
+
+
 describe('formatDuration', () => {
   it('formats seconds-only', () => {
     expect(formatDuration(45)).toBe('45s')
diff --git a/test/loop-permission-ruleset.test.ts b/test/loop-permission-ruleset.test.ts
index 5d627ab6e..31fd69c73 100644
--- a/test/loop-permission-ruleset.test.ts
+++ b/test/loop-permission-ruleset.test.ts
@@ -30,6 +30,7 @@ describe('buildLoopPermissionRuleset', () => {
       { permission: 'plan_exit',          pattern: '*', action: 'deny' },
       { permission: 'plan-write',         pattern: '*', action: 'deny' },
       { permission: 'plan-edit',          pattern: '*', action: 'deny' },
+      { permission: 'goal-write',         pattern: '*', action: 'deny' },
       { permission: 'execute-plan',       pattern: '*', action: 'deny' },
       { permission: 'execute-goal',       pattern: '*', action: 'deny' },
       { permission: 'question',           pattern: '*', action: 'deny' },
@@ -47,7 +48,7 @@ describe('buildLoopPermissionRuleset', () => {
   })
 
   test('EMITS session-level denies for code-agent tool exclusions (auditor now runs in separate session)', () => {
-    const required = ['review-write', 'review-delete', 'plan', 'plan_enter', 'plan_exit', 'plan-write', 'plan-edit', 'execute-plan', 'question']
+    const required = ['review-write', 'review-delete', 'plan', 'plan_enter', 'plan_exit', 'plan-write', 'plan-edit', 'goal-write', 'execute-plan', 'question']
     const rules = buildLoopPermissionRuleset()
     for (const tool of required) {
       expect(rules.find((r) => r.permission === tool && r.action === 'deny')).toBeDefined()
@@ -109,6 +110,7 @@ describe('buildAuditSessionPermissionRuleset', () => {
     // Plan-authoring tools: auditor's sanctioned path is plan-adjust, never plan-write/plan-edit.
     expect(rules.some(r => r.permission === 'plan-write' && r.pattern === '*' && r.action === 'deny')).toBe(true)
     expect(rules.some(r => r.permission === 'plan-edit' && r.pattern === '*' && r.action === 'deny')).toBe(true)
+    expect(rules.some(r => r.permission === 'goal-write' && r.pattern === '*' && r.action === 'deny')).toBe(true)
   })
 
   test('contains external_directory:*:deny rule', () => {
diff --git a/test/loop-tool-new-session.test.ts b/test/loop-tool-new-session.test.ts
index e45c3b0a0..15c280fd6 100644
--- a/test/loop-tool-new-session.test.ts
+++ b/test/loop-tool-new-session.test.ts
@@ -3,6 +3,7 @@ import { createLoopService } from '../src/loop/service'
 import { createLoopsRepo } from '../src/storage/repos/loops-repo'
 import { createPlansRepo } from '../src/storage/repos/plans-repo'
 import { createReviewFindingsRepo } from '../src/storage/repos/review-findings-repo'
+import { createGoalBriefsRepo } from '../src/storage/repos/goal-briefs-repo'
 import { createLoopTools } from '../src/tools/loop'
 import { createLogger } from '../src/utils/logger'
 import { createLoopEventHandler } from '../src/hooks/loop'
@@ -65,6 +66,7 @@ describe('loop tool mode=new-session', () => {
       logger,
       plansRepo,
       loopsRepo,
+      goalBriefsRepo: createGoalBriefsRepo(db),
       projectId,
       dataDir: dbPath,
       loop: loopHandler.loop,
@@ -234,6 +236,7 @@ describe('execute-goal tool', () => {
       logger,
       plansRepo,
       loopsRepo,
+      goalBriefsRepo: createGoalBriefsRepo(db),
       projectId,
       dataDir: dbPath,
       loop: loopHandler.loop,
@@ -242,15 +245,29 @@ describe('execute-goal tool', () => {
     return { tools, forgeClient, loopService }
   }
 
+  const BRIEF = `## Goal
+Ship the execute-goal feature end to end.
+
+## Context
+The legacy free-text launch path is being replaced by brief-backed launches.
+
+## Constraints
+No new dependencies.
+
+## Acceptance Criteria
+- the execute-goal tool launches from a stored goal brief
+`
+
   test('warns when the new session resolves to a different opencode project than the plugin scope', async () => {
     const { tools } = setupTools({
       session: {
         get: async () => ({ id: 'ses_fake_1', projectID: 'other-project' }),
       },
     } as any)
+    createGoalBriefsRepo(db).writeForSession(projectId, 'src-session', BRIEF)
 
     const result = await tools['execute-goal'].execute(
-      { goal: 'Ship it' } as any,
+      {} as any,
       { sessionID: 'src-session' } as any,
     )
 
@@ -265,9 +282,10 @@ describe('execute-goal tool', () => {
         get: async () => ({ id: 'ses_fake_1', projectID: projectId }),
       },
     } as any)
+    createGoalBriefsRepo(db).writeForSession(projectId, 'src-session', BRIEF)
 
     const result = await tools['execute-goal'].execute(
-      { goal: 'Ship it' } as any,
+      {} as any,
       { sessionID: 'src-session' } as any,
     )
 
@@ -275,25 +293,42 @@ describe('execute-goal tool', () => {
     expect(result).not.toContain('WARNING: The new session belongs to project')
   })
 
-  test('rejects a blank goal without provisioning any workspace or session', async () => {
+  test('rejects without provisioning any workspace or session when no brief is stored', async () => {
+    const { tools, forgeClient } = setupTools()
+
+    const result = await tools['execute-goal'].execute(
+      {} as any,
+      { sessionID: 'src-session' } as any,
+    )
+
+    expect(result).toContain('No goal brief stored for this session')
+    expect((forgeClient.workspace.create as any).mock.calls.length).toBe(0)
+    expect((forgeClient.session.create as any).mock.calls.length).toBe(0)
+    expect((forgeClient.workspace.warp as any).mock.calls.length).toBe(0)
+  })
+
+  test('rejects without provisioning when the stored brief is missing required headings', async () => {
     const { tools, forgeClient } = setupTools()
+    createGoalBriefsRepo(db).writeForSession(projectId, 'src-session', '## Goal\nShip it.\n')
 
     const result = await tools['execute-goal'].execute(
-      { goal: '   \n  ' } as any,
+      {} as any,
       { sessionID: 'src-session' } as any,
     )
 
-    expect(result).toContain('Goal text is required')
+    expect(result).toContain('execute-goal refused: the stored goal brief is incomplete')
+    expect(result).toContain('Missing required section')
     expect((forgeClient.workspace.create as any).mock.calls.length).toBe(0)
     expect((forgeClient.session.create as any).mock.calls.length).toBe(0)
     expect((forgeClient.workspace.warp as any).mock.calls.length).toBe(0)
   })
 
-  test('dispatches a managed goal loop in a new worktree session and persists goal text', async () => {
+  test('dispatches a managed goal loop from the stored brief in a new worktree session and persists the brief as the goal', async () => {
     const { tools, forgeClient, loopService } = setupTools()
+    createGoalBriefsRepo(db).writeForSession(projectId, 'src-session', BRIEF)
 
     const result = await tools['execute-goal'].execute(
-      { goal: 'Ship the execute-goal feature end to end' } as any,
+      {} as any,
       { sessionID: 'src-session' } as any,
     )
 
@@ -315,7 +350,7 @@ describe('execute-goal tool', () => {
     expect(state.sessionId).toBe('ses_fake_1')
     expect(state.executorSessionId).toBe('ses_fake_1')
     expect(state.hostSessionId).toBe('src-session')
-    expect(state.goal).toBe('Ship the execute-goal feature end to end')
+    expect(state.goal).toBe(BRIEF.trim())
     expect(state.phase).toBe('coding')
     expect(state.totalSections).toBe(0)
 
@@ -324,7 +359,7 @@ describe('execute-goal tool', () => {
 
     const loopsRepo = createLoopsRepo(db)
     const large = loopsRepo.getLarge(projectId, state.loopName)
-    expect(large?.goal).toBe('Ship the execute-goal feature end to end')
+    expect(large?.goal).toBe(BRIEF.trim())
   })
 
   test('does not regress execute-plan new-session mode (still creates a fresh session)', async () => {
diff --git a/test/loop/runtime.test.ts b/test/loop/runtime.test.ts
index 4c55f153b..f48f62d4d 100644
--- a/test/loop/runtime.test.ts
+++ b/test/loop/runtime.test.ts
@@ -2273,7 +2273,7 @@ describe('stall handling terminates with stall timeout when configured cap is re
   })
 
   describe('variant dispatch', () => {
-    test('coding prompt sends executionVariant from loop state', async () => {
+    test('coding prompt sends executionVariant with the default model', async () => {
       const { client, calls } = createFakeForgeClient({
         session: {
           messages: async () => [
@@ -2281,12 +2281,13 @@ describe('stall handling terminates with stall timeout when configured cap is re
           ],
         },
       })
-      const { loop } = createRuntime({ client })
+      const { loop } = createRuntime({ client, loopConfig: { executionModel: undefined } })
 
       const state = makeState({
         phase: 'auditing',
         totalSections: 0,
         auditCount: 1,
+        executionModel: undefined,
         executionVariant: 'thinking-max',
         auditorVariant: 'audit-high',
       })
@@ -2322,7 +2323,7 @@ describe('stall handling terminates with stall timeout when configured cap is re
       expect(afterState!.executorSessionId).toBeUndefined()
     })
 
-    test('auditor prompt sends auditorVariant from loop state', async () => {
+    test('auditor prompt sends auditorVariant with the default model', async () => {
       const { client, calls } = createFakeForgeClient({
         session: {
           messages: async () => [
@@ -2330,12 +2331,17 @@ describe('stall handling terminates with stall timeout when configured cap is re
           ],
         },
       })
-      const { loop } = createRuntime({ client })
+      const { loop } = createRuntime({
+        client,
+        loopConfig: { executionModel: undefined, auditorModel: undefined },
+      })
 
       const state = makeState({
         phase: 'coding',
         totalSections: 0,
         auditCount: 0,
+        executionModel: undefined,
+        auditorModel: undefined,
         executionVariant: 'thinking-max',
         auditorVariant: 'audit-high',
       })
@@ -2357,6 +2363,76 @@ describe('stall handling terminates with stall timeout when configured cap is re
       }
     })
 
+    test('persistent execution-model fallback omits the stored variant', async () => {
+      const { client, calls } = createFakeForgeClient({
+        session: {
+          messages: async () => [
+            { info: { role: 'assistant', finish: 'stop' }, parts: [{ type: 'text', text: 'Audit passed.' }] },
+          ],
+        },
+      })
+      const { loop } = createRuntime({ client })
+      const state = makeState({
+        phase: 'auditing',
+        totalSections: 0,
+        auditCount: 1,
+        modelFailed: true,
+        executionVariant: 'thinking-max',
+      })
+      loopService.setState(state.loopName, state)
+      reviewFindingsRepo.write({
+        projectId: PROJECT_ID,
+        loopName: state.loopName,
+        file: 'src/test.ts',
+        line: 1,
+        severity: 'bug',
+        description: 'Test bug',
+      })
+
+      await loop.tick({
+        type: 'session.status',
+        properties: {
+          status: { type: 'idle' },
+          sessionID: state.sessionId,
+        },
+      })
+
+      const codePrompts = calls.filter(c => c.method === 'session.promptAsync' && (c.params as any)?.agent === 'code')
+      expect(codePrompts.length).toBeGreaterThan(0)
+      expect(codePrompts.every(call => !(call.params as any)?.model && !(call.params as any)?.variant)).toBe(true)
+    })
+
+    test('persistent auditor-model fallback omits the stored variant', async () => {
+      const { client, calls } = createFakeForgeClient({
+        session: {
+          messages: async () => [
+            { info: { role: 'assistant', finish: 'stop' }, parts: [{ type: 'text', text: 'Coding complete.' }] },
+          ],
+        },
+      })
+      const { loop } = createRuntime({ client })
+      const state = makeState({
+        phase: 'coding',
+        totalSections: 0,
+        auditCount: 0,
+        modelFailed: true,
+        auditorVariant: 'audit-high',
+      })
+      loopService.setState(state.loopName, state)
+
+      await loop.tick({
+        type: 'session.status',
+        properties: {
+          status: { type: 'idle' },
+          sessionID: state.sessionId,
+        },
+      })
+
+      const auditorPrompts = calls.filter(c => c.method === 'session.promptAsync' && (c.params as any)?.agent === 'auditor-loop')
+      expect(auditorPrompts.length).toBeGreaterThan(0)
+      expect(auditorPrompts.every(call => !(call.params as any)?.model && !(call.params as any)?.variant)).toBe(true)
+    })
+
     test('model fallback omits variant when model is undefined', async () => {
       let failCount = 2
       const { client, calls } = createFakeForgeClient({
diff --git a/test/plan-execution.test.ts b/test/plan-execution.test.ts
index a4dd7ec87..22aaa90af 100644
--- a/test/plan-execution.test.ts
+++ b/test/plan-execution.test.ts
@@ -6,6 +6,9 @@ import {
   extractLoopNames,
   sanitizeLoopName,
   PLAN_EXECUTION_LABELS,
+  GOAL_EXECUTION_LABELS,
+  listLaunchModesForSpecKind,
+  getLaunchModeDescription,
 } from '../src/utils/plan-execution'
 
 describe('Plan Execution Utilities', () => {
@@ -25,6 +28,41 @@ describe('Plan Execution Utilities', () => {
     })
   })
 
+  describe('GOAL_EXECUTION_LABELS', () => {
+    test('Contains only the Loop label', () => {
+      expect(GOAL_EXECUTION_LABELS).toEqual(['Loop'])
+    })
+  })
+
+  describe('listLaunchModesForSpecKind', () => {
+    test('returns all three plan labels in canonical order', () => {
+      expect(listLaunchModesForSpecKind('plan')).toEqual(['New session', 'Execute here', 'Loop'])
+    })
+
+    test('returns exactly Loop for goal kind', () => {
+      expect(listLaunchModesForSpecKind('goal')).toEqual(['Loop'])
+      expect(listLaunchModesForSpecKind('goal')).toHaveLength(1)
+    })
+  })
+
+  describe('getLaunchModeDescription', () => {
+    test('returns byte-identical descriptions for all three plan labels', () => {
+      expect(getLaunchModeDescription('plan', 'New session')).toBe('Create a new session and send the plan to the code agent')
+      expect(getLaunchModeDescription('plan', 'Execute here')).toBe('Execute the plan in the current session using the code agent')
+      expect(getLaunchModeDescription('plan', 'Loop')).toBe('Execute using iterative development loop in an isolated git worktree (Docker sandbox used automatically when available)')
+    })
+
+    test('returns the goal-specific Loop description', () => {
+      expect(getLaunchModeDescription('goal', 'Loop')).toBe('Execute the goal brief using an iterative development loop in an isolated git worktree')
+    })
+
+    test('returns empty string for unknown labels', () => {
+      expect(getLaunchModeDescription('plan', 'Unknown')).toBe('')
+      expect(getLaunchModeDescription('goal', 'New session')).toBe('')
+      expect(getLaunchModeDescription('goal', 'Execute here')).toBe('')
+    })
+  })
+
   describe('extractPlanTitle', () => {
     test('Extracts title from first heading', () => {
       const plan = '# My Implementation Plan\n\nSome content here...'
diff --git a/test/prompts/loader.test.ts b/test/prompts/loader.test.ts
index cd792794d..ddc4f582d 100644
--- a/test/prompts/loader.test.ts
+++ b/test/prompts/loader.test.ts
@@ -59,6 +59,25 @@ describe('loadPrompt', () => {
     expect(prompt).toContain('**Verification**')
   })
 
+  test('goal agent prompt contains the four required brief headings, goal-write, and execute-goal', () => {
+    const prompt = loadPrompt(['agents', 'goal.md'])
+    expect(prompt).toContain('## Goal')
+    expect(prompt).toContain('## Context')
+    expect(prompt).toContain('## Constraints')
+    expect(prompt).toContain('## Acceptance Criteria')
+    expect(prompt).toContain('goal-write')
+    expect(prompt).toContain('execute-goal')
+    expect(prompt).toContain('question')
+    expect(prompt).not.toContain('<!-- forge-section -->')
+  })
+
+  test('goal command prompt contains $ARGUMENTS, goal-write, and execute-goal', () => {
+    const prompt = loadPrompt(['commands', 'goal.md'])
+    expect(prompt).toContain('$ARGUMENTS')
+    expect(prompt).toContain('goal-write')
+    expect(prompt).toContain('execute-goal')
+  })
+
   test('buildAgents with custom promptsDir uses the custom prompt', () => {
     const tmpDir = join(import.meta.dirname, '..', '..', '.forge', 'tmp', 'test-build-agents')
     mkdirSync(join(tmpDir, 'agents'), { recursive: true })
diff --git a/test/services/attach-loop.test.ts b/test/services/attach-loop.test.ts
index 3c085ffc2..7947a0b4d 100644
--- a/test/services/attach-loop.test.ts
+++ b/test/services/attach-loop.test.ts
@@ -685,8 +685,8 @@ describe('attachLoopToSession', () => {
     }
   })
 
-  test('attachLoopToSession persists execution and auditor variants', async () => {
-    const { deps, loopsRepo } = buildDeps()
+  test('attachLoopToSession persists variants and sends the execution variant without an explicit model', async () => {
+    const { deps, loopsRepo, promptAsyncMock } = buildDeps()
 
     const { attachLoopToSession } = await import('../../src/services/execution')
 
@@ -701,7 +701,6 @@ describe('attachLoopToSession', () => {
         displayName: 'Variant Loop',
         executionName: 'variant-loop',
         hostSessionId: 'host-variant',
-        executionModel: 'prov/exec',
         auditorModel: 'prov/aud',
         executionVariant: 'thinking-max',
         auditorVariant: 'audit-high',
@@ -728,5 +727,38 @@ describe('attachLoopToSession', () => {
     expect(row).not.toBeNull()
     expect(row!.executionVariant).toBe('thinking-max')
     expect(row!.auditorVariant).toBe('audit-high')
+
+    expect(promptAsyncMock.mock.calls[0][0]).toMatchObject({ variant: 'thinking-max' })
+    expect(promptAsyncMock.mock.calls[0][0]).not.toHaveProperty('model')
+  })
+
+  test('attachLoopToSession omits a model-specific variant when falling back to the default model', async () => {
+    const { deps, promptAsyncMock } = buildDeps()
+    promptAsyncMock.mockImplementation(async (input) => {
+      if (input.model) throw new Error('configured model failed')
+    })
+
+    const { attachLoopToSession } = await import('../../src/services/execution')
+    const result = await attachLoopToSession(
+      deps as any,
+      { surface: 'tui', projectId: PROJECT_ID, directory: '/tmp/test' },
+      {
+        sessionId: 'sess_variant_fallback',
+        workspaceId: 'ws_variant_fallback',
+        worktreeDir: '/tmp/wt/variant-fallback',
+        loopName: 'variant-fallback-loop',
+        displayName: 'Variant Fallback Loop',
+        executionName: 'variant-fallback-loop',
+        executionModel: 'prov/exec',
+        executionVariant: 'thinking-max',
+        maxIterations: 50,
+        sandboxEnabled: false,
+        planText: '# Variant fallback plan',
+      },
+    )
+
+    expect(result.ok).toBe(true)
+    expect(promptAsyncMock.mock.calls.some(([input]) => input.model && input.variant === 'thinking-max')).toBe(true)
+    expect(promptAsyncMock.mock.calls.some(([input]) => !input.model && !input.variant)).toBe(true)
   })
 })
diff --git a/test/services/execution.forge-loop-extra.test.ts b/test/services/execution.forge-loop-extra.test.ts
new file mode 100644
index 000000000..168acdac0
--- /dev/null
+++ b/test/services/execution.forge-loop-extra.test.ts
@@ -0,0 +1,81 @@
+import { describe, test, expect } from 'vitest'
+import { resolveForgeLoopExtraSpec } from '../../src/services/execution'
+
+describe('resolveForgeLoopExtraSpec', () => {
+  test('goal kind with non-blank goal returns trimmed goal', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: 'do the thing' })).toEqual({
+      ok: true,
+      kind: 'goal',
+      goal: 'do the thing',
+    })
+  })
+
+  test('goal kind trims surrounding whitespace from goal', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: '  do the thing  ' })).toEqual({
+      ok: true,
+      kind: 'goal',
+      goal: 'do the thing',
+    })
+  })
+
+  test('goal kind with blank goal is rejected', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: '   ' })).toEqual({
+      ok: false,
+      error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank',
+    })
+  })
+
+  test('goal kind with missing goal is rejected', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal' })).toEqual({
+      ok: false,
+      error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank',
+    })
+  })
+
+  test('goal kind with non-string goal is rejected', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: 42 } as unknown as Parameters<typeof resolveForgeLoopExtraSpec>[0])).toEqual({
+      ok: false,
+      error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank',
+    })
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: null } as unknown as Parameters<typeof resolveForgeLoopExtraSpec>[0])).toEqual({
+      ok: false,
+      error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank',
+    })
+    expect(resolveForgeLoopExtraSpec({ kind: 'goal', goal: { text: 'x' } } as unknown as Parameters<typeof resolveForgeLoopExtraSpec>[0])).toEqual({
+      ok: false,
+      error: 'forgeLoop.kind is "goal" but forgeLoop.goal is missing or blank',
+    })
+  })
+
+  test('plan kind with inline planSource and planText returns planText', () => {
+    expect(resolveForgeLoopExtraSpec({ planSource: 'inline', planText: 'X' })).toEqual({
+      ok: true,
+      kind: 'plan',
+      planText: 'X',
+    })
+  })
+
+  test('undefined config yields a plan result with empty planText (backwards compat)', () => {
+    expect(resolveForgeLoopExtraSpec(undefined)).toEqual({
+      ok: true,
+      kind: 'plan',
+      planText: '',
+    })
+  })
+
+  test('config without kind or planText yields empty planText', () => {
+    expect(resolveForgeLoopExtraSpec({ planSource: 'stored' })).toEqual({
+      ok: true,
+      kind: 'plan',
+      planText: '',
+    })
+  })
+
+  test('kind: "plan" is treated as a plan loop', () => {
+    expect(resolveForgeLoopExtraSpec({ kind: 'plan', planSource: 'inline', planText: 'Y' })).toEqual({
+      ok: true,
+      kind: 'plan',
+      planText: 'Y',
+    })
+  })
+})
diff --git a/test/storage-migrations.test.ts b/test/storage-migrations.test.ts
index 99aa5c4b3..ac471a99a 100644
--- a/test/storage-migrations.test.ts
+++ b/test/storage-migrations.test.ts
@@ -1123,3 +1123,44 @@ test('migration 141 is idempotent on re-opened databases', () => {
 
   db2.close()
 })
+
+test('migration 144 creates goal_briefs table on fresh databases', () => {
+  const dbPath = createTempDb()
+  const db = openForgeDatabase(dbPath)
+
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='goal_briefs'").all() as Array<{ name: string }>
+  expect(tables.some((t) => t.name === 'goal_briefs')).toBe(true)
+
+  const cols = db.prepare('PRAGMA table_info(goal_briefs)').all() as Array<{ name: string; pk: number; notnull: number }>
+  const colNames = cols.map((c) => c.name)
+  expect(colNames).toContain('project_id')
+  expect(colNames).toContain('session_id')
+  expect(colNames).toContain('content')
+  expect(colNames).toContain('updated_at')
+
+  const pkCols = cols.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk)
+  expect(pkCols[0].name).toBe('project_id')
+  expect(pkCols[1].name).toBe('session_id')
+
+  const count = db.prepare('SELECT COUNT(*) as count FROM migrations WHERE id = ?').get('144') as { count: number }
+  expect(count.count).toBe(1)
+
+  db.close()
+})
+
+test('migration 144 is idempotent on re-opened databases', () => {
+  const dbPath = createTempDb()
+
+  const db1 = openForgeDatabase(dbPath)
+  db1.close()
+
+  const db2 = openForgeDatabase(dbPath)
+
+  const tables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='goal_briefs'").all() as Array<{ name: string }>
+  expect(tables.filter((t) => t.name === 'goal_briefs')).toHaveLength(1)
+
+  const count = db2.prepare('SELECT COUNT(*) as count FROM migrations WHERE id = ?').get('144') as { count: number }
+  expect(count.count).toBe(1)
+
+  db2.close()
+})
diff --git a/test/tools/goal-authoring.test.ts b/test/tools/goal-authoring.test.ts
new file mode 100644
index 000000000..9f25ea9ab
--- /dev/null
+++ b/test/tools/goal-authoring.test.ts
@@ -0,0 +1,291 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import type { Database } from 'bun:sqlite'
+import { Database as Sqlite } from 'bun:sqlite'
+import { mkdtempSync, rmSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { createGoalAuthoringTools } from '../../src/tools/goal-authoring'
+import { createGoalBriefsRepo } from '../../src/storage/repos/goal-briefs-repo'
+import { createLoopsRepo } from '../../src/storage/repos/loops-repo'
+import { createPlansRepo } from '../../src/storage/repos/plans-repo'
+import { createReviewFindingsRepo } from '../../src/storage/repos/review-findings-repo'
+import { createLoopService } from '../../src/loop/service'
+import type { Logger } from '../../src/types'
+import type { ToolContext } from '../../src/tools/types'
+
+const mockLogger: Logger = {
+  log: () => {},
+  error: () => {},
+  debug: () => {},
+}
+
+function describeGoal() {
+  return `## Goal
+Ship the goal-brief launch feature.
+
+## Context
+Goal briefs are authored before the loop is launched.
+
+## Constraints
+No plan structure inside the brief.
+
+## Acceptance Criteria
+- goal-write writes a brief.
+`
+}
+
+describe('goal-write', () => {
+  let db: Database
+  let tempDir: string
+  let tools: ReturnType<typeof createGoalAuthoringTools>
+  let goalBriefsRepo: ReturnType<typeof createGoalBriefsRepo>
+  let loopsRepo: ReturnType<typeof createLoopsRepo>
+  const projectId = 'test-project'
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'goal-authoring-test-'))
+    db = new Sqlite(join(tempDir, 'test.db'))
+
+    db.run(`
+      CREATE TABLE loops (
+        project_id           TEXT NOT NULL,
+        loop_name            TEXT NOT NULL,
+        status               TEXT NOT NULL,
+        current_session_id   TEXT NOT NULL,
+        worktree             INTEGER NOT NULL,
+        worktree_dir         TEXT NOT NULL,
+        worktree_branch      TEXT,
+        project_dir          TEXT NOT NULL,
+        max_iterations       INTEGER NOT NULL,
+        iteration            INTEGER NOT NULL DEFAULT 0,
+        audit_count          INTEGER NOT NULL DEFAULT 0,
+        error_count          INTEGER NOT NULL DEFAULT 0,
+        phase                TEXT NOT NULL,
+        execution_model      TEXT,
+        auditor_model        TEXT,
+        model_failed         INTEGER NOT NULL DEFAULT 0,
+        sandbox              INTEGER NOT NULL DEFAULT 0,
+        sandbox_container    TEXT,
+        started_at           INTEGER NOT NULL,
+        completed_at         INTEGER,
+        termination_reason   TEXT,
+        completion_summary   TEXT,
+        workspace_id         TEXT,
+        host_session_id      TEXT,
+        session_directory    TEXT,
+        current_section_index INTEGER NOT NULL DEFAULT 0,
+        total_sections       INTEGER NOT NULL DEFAULT 0,
+        final_audit_done     INTEGER NOT NULL DEFAULT 0,
+        final_audit_attempts INTEGER NOT NULL DEFAULT 0,
+        execution_variant    TEXT,
+        auditor_variant      TEXT,
+        loop_kind            TEXT NOT NULL DEFAULT 'plan',
+        executor_session_id  TEXT,
+        PRIMARY KEY (project_id, loop_name)
+      )
+    `)
+
+    db.run(`
+      CREATE TABLE loop_large_fields (
+        project_id          TEXT NOT NULL,
+        loop_name           TEXT NOT NULL,
+        last_audit_result   TEXT,
+        post_action_report  TEXT,
+        goal                TEXT,
+        PRIMARY KEY (project_id, loop_name),
+        FOREIGN KEY (project_id, loop_name) REFERENCES loops(project_id, loop_name) ON DELETE CASCADE
+      )
+    `)
+
+    db.run(`
+      CREATE TABLE plans (
+        project_id   TEXT NOT NULL,
+        loop_name    TEXT,
+        session_id   TEXT,
+        content      TEXT NOT NULL,
+        updated_at   INTEGER NOT NULL,
+        CHECK (loop_name IS NOT NULL OR session_id IS NOT NULL),
+        CHECK (NOT (loop_name IS NOT NULL AND session_id IS NOT NULL)),
+        UNIQUE (project_id, loop_name),
+        UNIQUE (project_id, session_id)
+      )
+    `)
+
+    db.run(`
+      CREATE TABLE review_findings (
+        project_id TEXT NOT NULL,
+        loop_name TEXT NOT NULL DEFAULT '',
+        file TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        severity TEXT NOT NULL,
+        description TEXT NOT NULL,
+        scenario TEXT,
+        created_at INTEGER NOT NULL,
+        section_index INTEGER,
+        PRIMARY KEY (project_id, loop_name, file, line, section_index)
+      )
+    `)
+
+    db.run(`
+      CREATE TABLE goal_briefs (
+        project_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        content    TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (project_id, session_id)
+      )
+    `)
+
+    goalBriefsRepo = createGoalBriefsRepo(db)
+    loopsRepo = createLoopsRepo(db)
+    const plansRepo = createPlansRepo(db)
+    const reviewFindingsRepo = createReviewFindingsRepo(db)
+    const loopService = createLoopService(loopsRepo, plansRepo, reviewFindingsRepo, projectId, mockLogger)
+
+    const ctx = {
+      goalBriefsRepo,
+      plansRepo,
+      loopsRepo,
+      reviewFindingsRepo,
+      projectId,
+      logger: mockLogger,
+      loop: { service: loopService },
+      directory: tempDir,
+    } as unknown as ToolContext
+
+    tools = createGoalAuthoringTools(ctx)
+  })
+
+  afterEach(() => {
+    db.close()
+    try { rmSync(tempDir, { recursive: true, force: true }) } catch {}
+  })
+
+  function makeToolContext(sessionID: string) {
+    return { sessionID } as any
+  }
+
+  function insertRunningLoop(loopName: string, sessionId: string) {
+    loopsRepo.insert(
+      {
+        projectId,
+        loopName,
+        status: 'running',
+        currentSessionId: sessionId,
+        worktree: false,
+        worktreeDir: tempDir,
+        worktreeBranch: 'feature-branch',
+        projectDir: tempDir,
+        maxIterations: 10,
+        iteration: 1,
+        auditCount: 0,
+        errorCount: 0,
+        phase: 'coding',
+        executionModel: 'test-model',
+        auditorModel: 'test-auditor',
+        modelFailed: false,
+        sandbox: false,
+        sandboxContainer: null,
+        startedAt: Date.now(),
+        completedAt: null,
+        terminationReason: null,
+        completionSummary: null,
+        workspaceId: null,
+        hostSessionId: null,
+        currentSectionIndex: 0,
+        totalSections: 0,
+        finalAuditDone: 0,
+        executionVariant: null,
+        auditorVariant: null,
+        kind: 'plan',
+      },
+      { lastAuditResult: null },
+    )
+  }
+
+  test('writes a clean brief to goal_briefs, not plans, and returns the stored report', async () => {
+    const content = describeGoal()
+    const result = await tools['goal-write'].execute({ content }, makeToolContext('sess-1'))
+
+    expect(result).toMatch(/^Goal brief stored: \d+ lines, \d+ chars\./)
+    const row = goalBriefsRepo.getForSession(projectId, 'sess-1')
+    expect(row).not.toBeNull()
+    expect(row!.content).toBe(content)
+  })
+
+  test('content with a forge-section marker performs no write and returns a goal-write failed message', async () => {
+    const content = `${describeGoal()}\n<!-- forge-section -->\n## Phase 1\n- do one\n`
+    const result = await tools['goal-write'].execute({ content }, makeToolContext('sess-1'))
+
+    expect(result).toMatch(/^goal-write failed:/)
+    expect(goalBriefsRepo.getForSession(projectId, 'sess-1')).toBeNull()
+  })
+
+  test('content with a Phase heading performs no write and returns a goal-write failed message', async () => {
+    const content = `${describeGoal()}\n## Phase 1: Build it\n- do one\n`
+    const result = await tools['goal-write'].execute({ content }, makeToolContext('sess-1'))
+
+    expect(result).toMatch(/^goal-write failed:/)
+    expect(goalBriefsRepo.getForSession(projectId, 'sess-1')).toBeNull()
+  })
+
+  test('a brief missing ## Constraints still writes and the report warns about it', async () => {
+    const content = `## Goal
+Ship the feature.
+
+## Context
+Some context.
+
+## Acceptance Criteria
+- it works.
+`
+    const result = await tools['goal-write'].execute({ content }, makeToolContext('sess-1'))
+
+    expect(result).toMatch(/^Goal brief stored:/)
+    expect(result).toContain('Warnings:')
+    expect(result).toContain('Missing required section: ## Constraints')
+    expect(goalBriefsRepo.getForSession(projectId, 'sess-1')!.content).toBe(content)
+  })
+
+  test('append: true concatenates onto existing content with exactly two newlines', async () => {
+    const existing = `${describeGoal()}`
+    goalBriefsRepo.writeForSession(projectId, 'sess-1', existing)
+
+    const fragment = '## Notes\nAdditional context.\n'
+    const result = await tools['goal-write'].execute(
+      { content: fragment, append: true },
+      makeToolContext('sess-1'),
+    )
+
+    expect(result).toMatch(/^Goal brief stored:/)
+    const row = goalBriefsRepo.getForSession(projectId, 'sess-1')
+    expect(row!.content).toBe(`${existing.trimEnd()}\n\n${fragment}`)
+  })
+
+  test('append: true on an empty store behaves as a create', async () => {
+    const fragment = describeGoal()
+    const result = await tools['goal-write'].execute(
+      { content: fragment, append: true },
+      makeToolContext('sess-1'),
+    )
+
+    expect(result).toMatch(/^Goal brief stored:/)
+    const row = goalBriefsRepo.getForSession(projectId, 'sess-1')
+    expect(row).not.toBeNull()
+    expect(row!.content).toBe(fragment)
+  })
+
+  test('from a running-loop session performs no write and names the goal brief and active loop session', async () => {
+    insertRunningLoop('test-loop', 'sess-1')
+
+    const result = await tools['goal-write'].execute(
+      { content: describeGoal() },
+      makeToolContext('sess-1'),
+    )
+
+    expect(result).toContain('goal brief')
+    expect(result).toContain('active loop session')
+    expect(result).toContain('test-loop')
+    expect(goalBriefsRepo.getForSession(projectId, 'sess-1')).toBeNull()
+  })
+})
diff --git a/test/tui-client.loop-error.test.ts b/test/tui-client.loop-error.test.ts
index ba0994763..2fd99d400 100644
--- a/test/tui-client.loop-error.test.ts
+++ b/test/tui-client.loop-error.test.ts
@@ -84,7 +84,7 @@ describe('plan.execute(loop) workspace.create failure', () => {
     const result = await project.plan.execute('sess-1', {
       mode: 'loop',
       title: 'Test Loop',
-      plan: '# Test\n\nLoop test plan.',
+      spec: { kind: 'plan', text: '# Test\n\nLoop test plan.', updatedAt: 0 },
     })
 
     expect(result).not.toBeNull()
@@ -110,7 +110,7 @@ describe('plan.execute(loop) workspace.create failure', () => {
     const result = await project.plan.execute('sess-1', {
       mode: 'loop',
       title: 'Empty Error Loop',
-      plan: '# Test\n\nEmpty error test.',
+      spec: { kind: 'plan', text: '# Test\n\nEmpty error test.', updatedAt: 0 },
     })
 
     if (result && 'error' in result) {
@@ -145,7 +145,7 @@ describe('plan.execute(loop) workspace.create failure', () => {
     const result = await project.plan.execute('sess-1', {
       mode: 'loop',
       title: 'PostCreate Fail',
-      plan: '# Test\n\nPost-create failure test.',
+      spec: { kind: 'plan', text: '# Test\n\nPost-create failure test.', updatedAt: 0 },
     })
 
     // Post-create failures surface the underlying cause instead of a generic null
@@ -171,7 +171,7 @@ describe('plan.execute(loop) workspace.create failure', () => {
     const result = await project.plan.execute('sess-1', {
       mode: 'loop',
       title: 'Global Project Loop',
-      plan: '# Test\n\nShould fail fast.',
+      spec: { kind: 'plan', text: '# Test\n\nShould fail fast.', updatedAt: 0 },
     })
 
     expect(result).not.toBeNull()
diff --git a/test/utils/goal-brief.test.ts b/test/utils/goal-brief.test.ts
new file mode 100644
index 000000000..7063b34d6
--- /dev/null
+++ b/test/utils/goal-brief.test.ts
@@ -0,0 +1,120 @@
+import { describe, test, expect } from 'vitest'
+import {
+  GOAL_BRIEF_REQUIRED_HEADINGS,
+  summarizeGoalBrief,
+  formatGoalBriefSummary,
+  hasPlanStructureViolations,
+} from '../../src/utils/goal-brief'
+
+function cleanBrief(): string {
+  return ['## Goal', 'Ship the validator.', '## Context', 'Phase 2 of the loop.', '## Constraints', 'No new deps.', '## Acceptance Criteria', 'Tests pass.'].join('\n')
+}
+
+describe('GOAL_BRIEF_REQUIRED_HEADINGS', () => {
+  test('exposes the canonical four headings', () => {
+    expect([...GOAL_BRIEF_REQUIRED_HEADINGS]).toEqual([
+      'Goal',
+      'Context',
+      'Constraints',
+      'Acceptance Criteria',
+    ])
+  })
+})
+
+describe('summarizeGoalBrief', () => {
+  test('returns empty missingHeadings when all four ## headings are present', () => {
+    const structure = summarizeGoalBrief(cleanBrief())
+    expect(structure.missingHeadings).toEqual([])
+  })
+
+  test('reports only the missing canonical heading name', () => {
+    const brief = cleanBrief().split('\n').filter((line) => line !== '## Constraints').join('\n')
+    const structure = summarizeGoalBrief(brief)
+    expect(structure.missingHeadings).toEqual(['Constraints'])
+    expect(formatGoalBriefSummary(structure)).toContain('- Missing required section: ## Constraints')
+  })
+
+  test('matches required headings case-insensitively', () => {
+    const brief = [
+      '## goal',
+      '## CONTEXT',
+      '## constraints',
+      '## acceptance criteria',
+      'body',
+    ].join('\n')
+    expect(summarizeGoalBrief(brief).missingHeadings).toEqual([])
+  })
+
+  test('does not satisfy a requirement with a ### nested heading', () => {
+    const brief = [
+      '## Goal',
+      '### Context',
+      '## Constraints',
+      '## Acceptance Criteria',
+      'body',
+    ].join('\n')
+    const structure = summarizeGoalBrief(brief)
+    expect(structure.missingHeadings).toEqual(['Context'])
+  })
+
+  test('flags a forge-section marker as a plan structure violation', () => {
+    const brief = `${cleanBrief()}\n<!-- forge-section -->`
+    const structure = summarizeGoalBrief(brief)
+    expect(structure.planStructureViolations).toContain('<!-- forge-section --> marker')
+    expect(hasPlanStructureViolations(structure)).toBe(true)
+  })
+
+  test('flags ## Phase and ### Phase headings', () => {
+    const brief2 = `${cleanBrief()}\n## Phase 1: Something`
+    const brief3 = `${cleanBrief()}\n### Phase 2: Other`
+    expect(summarizeGoalBrief(brief2).planStructureViolations).toContain('Phase heading')
+    expect(summarizeGoalBrief(brief3).planStructureViolations).toContain('Phase heading')
+  })
+
+  test('does not flag the word "phase" appearing in prose', () => {
+    const brief = `${cleanBrief()}\n- rolled out in a later phase`
+    const structure = summarizeGoalBrief(brief)
+    expect(structure.planStructureViolations).not.toContain('Phase heading')
+    expect(hasPlanStructureViolations(structure)).toBe(false)
+  })
+
+  test('reports both violations when marker and phase heading coexist', () => {
+    const brief = `${cleanBrief()}\n<!-- forge-section -->\n## Phase 1: Build`
+    const structure = summarizeGoalBrief(brief)
+    expect(structure.planStructureViolations).toEqual([
+      '<!-- forge-section --> marker',
+      'Phase heading',
+    ])
+  })
+
+  test('counts lines and chars', () => {
+    const text = 'a\nb\nc'
+    const structure = summarizeGoalBrief(text)
+    expect(structure.lines).toBe(3)
+    expect(structure.chars).toBe(5)
+  })
+})
+
+describe('formatGoalBriefSummary', () => {
+  test('emits only the count line for a clean brief', () => {
+    const structure = summarizeGoalBrief(cleanBrief())
+    const report = formatGoalBriefSummary(structure)
+    const lines = report.split('\n')
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toMatch(/^Goal brief stored: \d+ lines, \d+ chars\.$/)
+  })
+
+  test('renders Warnings and Plan structure not allowed blocks when present', () => {
+    const brief = '## Goal\nbody'
+    const structure = summarizeGoalBrief(`${brief}\n<!-- forge-section -->\n## Phase 1: X`)
+    const report = formatGoalBriefSummary(structure)
+    expect(report).toContain('Goal brief stored:')
+    expect(report).toContain('Warnings:')
+    expect(report).toContain('- Missing required section: ## Context')
+    expect(report).toContain('- Missing required section: ## Constraints')
+    expect(report).toContain('- Missing required section: ## Acceptance Criteria')
+    expect(report).toContain('Plan structure not allowed:')
+    expect(report).toContain('- <!-- forge-section --> marker')
+    expect(report).toContain('- Phase heading')
+  })
+})
diff --git a/test/utils/session-launch-spec.test.ts b/test/utils/session-launch-spec.test.ts
new file mode 100644
index 000000000..7d816b7c9
--- /dev/null
+++ b/test/utils/session-launch-spec.test.ts
@@ -0,0 +1,77 @@
+import { describe, test, expect } from 'vitest'
+import { extractLaunchSpecMetadata, type SessionLaunchSpec } from '../../src/utils/session-launch-spec'
+import { extractPlanExecutionMetadata } from '../../src/utils/plan-execution'
+
+function planSpec(text: string, updatedAt = 1): SessionLaunchSpec {
+  return { kind: 'plan', text, updatedAt }
+}
+
+function goalSpec(text: string, updatedAt = 1): SessionLaunchSpec {
+  return { kind: 'goal', text, updatedAt }
+}
+
+describe('extractLaunchSpecMetadata', () => {
+  test('plan kind delegates exactly to extractPlanExecutionMetadata', () => {
+    const text = '# Add retry to uploader\n## Loop Name: add-retry-uploader\nbody'
+    const spec = planSpec(text)
+    const expected = extractPlanExecutionMetadata(text)
+    expect(extractLaunchSpecMetadata(spec)).toEqual({ title: expected.title, executionName: expected.executionName })
+  })
+
+  test('goal kind derives title from first non-blank line after ## Goal', () => {
+    const brief = '# Goal Brief\n\n## Context\nSome context.\n\n## Goal\n\nAdd retry to the uploader\n\n## Acceptance Criteria\n- It retries.'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title).toBe('Add retry to the uploader')
+    expect(result.executionName).toBe('add-retry-to-the-uploader')
+  })
+
+  test('goal kind falls back to first non-heading line when ## Goal is absent', () => {
+    const brief = '# Goal Brief\n\n## Context\n\nBuild the uploader retry feature.\n'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title).toBe('Build the uploader retry feature.')
+    expect(result.executionName).toBe('build-the-uploader-retry-feature')
+  })
+
+  test('goal kind falls back to first non-heading line when ## Goal body is blank', () => {
+    const brief = '## Goal\n\n## Acceptance Criteria\n\nCool thing happening here.'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title).toBe('Cool thing happening here.')
+  })
+
+  test('goal kind caps the title at 80 chars with ellipsis', () => {
+    const longLine = 'a'.repeat(120)
+    const brief = `## Goal\n\n${longLine}\n`
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title.length).toBe(80)
+    expect(result.title.endsWith('…')).toBe(true)
+    expect(result.title).toBe(`${'a'.repeat(79)}…`)
+  })
+
+  test('goal kind slug derivation matches sanitizeLoopName', () => {
+    const brief = '## Goal\n\nAdd Retry To The Uploader!'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.executionName).toBe('add-retry-to-the-uploader')
+  })
+
+  test('goal kind preserves body text containing # characters', () => {
+    const brief = '# Goal Brief\n\n## Goal\n\nSupport C# clients\n'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title).toBe('Support C# clients')
+    expect(result.executionName).toBe('support-c-clients')
+  })
+
+  test('goal kind skips whitespace-only lines before the body', () => {
+    const brief = 'Some context prose here.\n\n## Goal\n\n   \n\n\t\n\nAdd retry to the uploader\n'
+    const result = extractLaunchSpecMetadata(goalSpec(brief))
+    expect(result.title).toBe('Add retry to the uploader')
+  })
+
+  test('goal heading match is case-insensitive, mirroring summarizeGoalBrief', () => {
+    const canonical = '## Goal\n\nAdd retry to the uploader'
+    const lower = '## goal\n\nAdd retry to the uploader'
+    const mixed = '## GoAl\n\nAdd retry to the uploader'
+    const expected = extractLaunchSpecMetadata(goalSpec(canonical))
+    expect(extractLaunchSpecMetadata(goalSpec(lower))).toEqual(expected)
+    expect(extractLaunchSpecMetadata(goalSpec(mixed))).toEqual(expected)
+  })
+})
diff --git a/test/utils/tui-client-loop-inline-plan.test.ts b/test/utils/tui-client-loop-inline-plan.test.ts
index 13ae25c1f..857a3e7b0 100644
--- a/test/utils/tui-client-loop-inline-plan.test.ts
+++ b/test/utils/tui-client-loop-inline-plan.test.ts
@@ -88,7 +88,7 @@ describe('Load Plans inline plan is sent as inline even when host session exists
       {
         mode: 'loop',
         title: 'My Plan',
-        plan: '# My Plan\n\nFresh content',
+        spec: { kind: 'plan', text: '# My Plan\n\nFresh content', updatedAt: 0 },
         executionModel: undefined,
         auditorModel: undefined,
       },
@@ -131,7 +131,7 @@ describe('Load Plans inline plan is sent as inline even when host session exists
       {
         mode: 'loop',
         title: 'My Plan',
-        plan,
+        spec: { kind: 'plan', text: plan, updatedAt: 0 },
         executionModel: undefined,
         auditorModel: undefined,
       },
@@ -151,7 +151,7 @@ describe('Load Plans inline plan is sent as inline even when host session exists
     await client!.plan.execute(SESSION_ID, {
       mode: 'loop',
       title: 'My Plan',
-      plan: '# My Plan\n\nFresh content',
+      spec: { kind: 'plan', text: '# My Plan\n\nFresh content', updatedAt: 0 },
       executionModel: undefined,
       auditorModel: undefined,
     })
diff --git a/test/utils/tui-client-stored-plan.test.ts b/test/utils/tui-client-stored-plan.test.ts
index 62652bcb2..528ba50f3 100644
--- a/test/utils/tui-client-stored-plan.test.ts
+++ b/test/utils/tui-client-stored-plan.test.ts
@@ -41,7 +41,7 @@ function makeDbPath(): string {
   return join(tmpdir(), `forge-tui-client-stored-plan-${randomUUID()}.db`)
 }
 
-describe('connectForgeProject.loadLatestPlan honors configured dataDir', () => {
+describe('connectForgeProject.loadLaunchSpec honors configured dataDir', () => {
   let mockApi: any
 
   beforeEach(() => {
@@ -75,8 +75,8 @@ describe('connectForgeProject.loadLatestPlan honors configured dataDir', () => {
     const client = await connectForgeProject(mockApi, DIRECTORY, [], dbPath)
     expect(client).not.toBeNull()
 
-    const plan = await client!.loadLatestPlan(SESSION_ID)
-    expect(plan).toBe('# Stored Plan\n## Phase 1\nbody')
+    const spec = await client!.loadLaunchSpec(SESSION_ID)
+    expect(spec).toEqual({ kind: 'plan', text: '# Stored Plan\n## Phase 1\nbody', updatedAt: expect.any(Number) })
 
     // Storage-first means the chat scan must not run when a stored row exists.
     expect(mockApi.client.session.messages).not.toHaveBeenCalled()
@@ -90,8 +90,8 @@ describe('connectForgeProject.loadLatestPlan honors configured dataDir', () => {
     const client = await connectForgeProject(mockApi, DIRECTORY, [], dbPath)
     expect(client).not.toBeNull()
 
-    const plan = await client!.loadLatestPlan(SESSION_ID)
-    expect(plan).toBeNull()
+    const spec = await client!.loadLaunchSpec(SESSION_ID)
+    expect(spec).toBeNull()
 
     // No stored plan → the message-scan fallback runs.
     expect(mockApi.client.session.messages).toHaveBeenCalledTimes(1)
@@ -102,16 +102,37 @@ describe('connectForgeProject.loadLatestPlan honors configured dataDir', () => {
   })
 
   test('with no dbPath override, reads from the default data dir path (still null for unknown session)', async () => {
-    // No configured dataDir → connectForgeProject receives undefined and
-    // fetchStoredSessionPlan falls back to the default path. We can't write
-    // into the real default DB from a test, so we only assert that the
-    // chat-scan fallback is reached (proving the default path was tried and
-    // missed).
     const client = await connectForgeProject(mockApi, DIRECTORY, [], undefined)
     expect(client).not.toBeNull()
 
-    const plan = await client!.loadLatestPlan(SESSION_ID)
-    expect(plan).toBeNull()
+    const spec = await client!.loadLaunchSpec(SESSION_ID)
+    expect(spec).toBeNull()
     expect(mockApi.client.session.messages).toHaveBeenCalledTimes(1)
   })
+
+  test('chat-scan fallback wraps a discovered plan as kind: plan', async () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    db.close()
+
+    mockApi.client.session.messages = vi.fn().mockResolvedValue({
+      data: [
+        {
+          info: { role: 'assistant', id: 'msg-1' },
+          parts: [
+            {
+              type: 'text',
+              text: '<!-- forge-plan:start -->\n# Scanned Plan\n## Phase 1\nbody\n<!-- forge-plan:end -->',
+            },
+          ],
+        },
+      ],
+    })
+
+    const client = await connectForgeProject(mockApi, DIRECTORY, [], dbPath)
+    expect(client).not.toBeNull()
+
+    const spec = await client!.loadLaunchSpec(SESSION_ID)
+    expect(spec).toEqual({ kind: 'plan', text: '# Scanned Plan\n## Phase 1\nbody', updatedAt: 0 })
+  })
 })
diff --git a/test/utils/tui-client-warp-flow.test.ts b/test/utils/tui-client-warp-flow.test.ts
index 725770f25..f7b7ea63b 100644
--- a/test/utils/tui-client-warp-flow.test.ts
+++ b/test/utils/tui-client-warp-flow.test.ts
@@ -113,7 +113,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'My Cool Feature',
-        plan: '# Plan\n\nImplement feature X.',
+        spec: { kind: 'plan', text: '# Plan\n\nImplement feature X.', updatedAt: 0 },
         executionModel: 'prov/exec',
         auditorModel: 'prov/aud',
       },
@@ -153,6 +153,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       planSource: 'inline',
       planText: '# Plan\n\nImplement feature X.',
       initialPromptOwner: 'tui',
+      maxIterations: 0,
       pendingAttachStartedAt: expect.any(Number),
     })
 
@@ -198,7 +199,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'My Cool Feature',
-        plan: '# Plan\n\nImplement feature X.',
+        spec: { kind: 'plan', text: '# Plan\n\nImplement feature X.', updatedAt: 0 },
       },
     )
 
@@ -225,7 +226,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'My Cool Feature',
-        plan: '# Plan\n\nImplement feature X.',
+        spec: { kind: 'plan', text: '# Plan\n\nImplement feature X.', updatedAt: 0 },
       },
     )
 
@@ -247,7 +248,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'My Cool Feature',
-        plan: '# Plan\n\nImplement feature X.',
+        spec: { kind: 'plan', text: '# Plan\n\nImplement feature X.', updatedAt: 0 },
       },
     )
 
@@ -268,7 +269,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'Fail Loop',
-        plan: '# Fail Plan\n\nThis will fail.',
+        spec: { kind: 'plan', text: '# Fail Plan\n\nThis will fail.', updatedAt: 0 },
       },
     )
 
@@ -290,7 +291,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'No Data Loop',
-        plan: '# No Data\n\nShould fail.',
+        spec: { kind: 'plan', text: '# No Data\n\nShould fail.', updatedAt: 0 },
       },
     )
 
@@ -307,7 +308,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'Sess Fail Loop',
-        plan: '# Session Fail.\n',
+        spec: { kind: 'plan', text: '# Session Fail.\n', updatedAt: 0 },
       },
     )
 
@@ -327,7 +328,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: 'Archived Plan Loop',
-        plan: '# Archived Plan\n\nLoaded from disk.',
+        spec: { kind: 'plan', text: '# Archived Plan\n\nLoaded from disk.', updatedAt: 0 },
         executionModel: 'prov/exec',
         auditorModel: 'prov/aud',
       },
@@ -345,6 +346,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       planText: '# Archived Plan\n\nLoaded from disk.',
       hostSessionId: undefined,
       initialPromptOwner: 'tui',
+      maxIterations: 0,
       pendingAttachStartedAt: expect.any(Number),
     })
     expect(createArgs.extra.forgeLoop.hostSessionId).toBeUndefined()
@@ -359,7 +361,7 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
       {
         mode: 'loop',
         title: longTitle,
-        plan: '# Long Title Test.',
+        spec: { kind: 'plan', text: '# Long Title Test.', updatedAt: 0 },
       },
     )
 
@@ -367,4 +369,107 @@ describe('TUI warp flow for plan.execute mode=loop', () => {
     const sesCreateArgs = mockApi.client.session.create.mock.calls[0][0]
     expect(sesCreateArgs.title).toBe('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
   })
+
+  describe('goal launches', () => {
+    const GOAL_BRIEF = '## Goal\n\nShip the launch button\n\n## Context\n\nWe need a clean rollout.'
+
+    test('goal loop: workspace.create carries kind=goal, goal text, initialPromptOwner=server, and no plan fields', async () => {
+      const client = await connectForgeProject(mockApi, DIRECTORY)
+      expect(client).not.toBeNull()
+
+      const result = await client!.plan.execute(
+        SESSION_ID,
+        {
+          mode: 'loop',
+          title: 'Ship the launch button',
+          spec: { kind: 'goal', text: GOAL_BRIEF, updatedAt: 0 },
+        },
+      )
+
+      expect(result).not.toBeNull()
+      expect(result!.sessionId).toBe('sess_new')
+      expect(result!.loopName).toBe('ship-the-launch-button')
+      expect(result!.workspaceId).toBe('ws_loop')
+
+      expect(mockApi.client.session.create).toHaveBeenCalledTimes(1)
+      expect(mockApi.client.session.promptAsync).not.toHaveBeenCalled()
+
+      const createArgs = mockApi.client.experimental.workspace.create.mock.calls[0][0]
+      const forgeLoop = createArgs.extra.forgeLoop
+      expect(forgeLoop.kind).toBe('goal')
+      expect(forgeLoop.goal).toBe(GOAL_BRIEF)
+      expect(forgeLoop.initialPromptOwner).toBe('server')
+      expect(forgeLoop.planSource).toBeUndefined()
+      expect(forgeLoop.planText).toBeUndefined()
+      expect(forgeLoop.title).toBe('Ship the launch button')
+      expect(forgeLoop.hostSessionId).toBe(SESSION_ID)
+
+      expect(callOrder).toContain('route.navigate')
+      expect(mockApi.route.navigate).toHaveBeenCalledWith('session', { sessionID: 'sess_new' })
+      expect(mockApi.client.experimental.workspace.syncList).toHaveBeenCalledTimes(2)
+    })
+
+    test('goal loop reserves a unique loop name and removes stale forge workspaces for that name', async () => {
+      mockApi.client.experimental.workspace.list.mockResolvedValueOnce({
+        data: [
+          { id: 'ws_old', type: 'forge', name: 'ship-the-launch-button' },
+        ],
+      })
+
+      const client = await connectForgeProject(mockApi, DIRECTORY)
+
+      const result = await client!.plan.execute(
+        SESSION_ID,
+        {
+          mode: 'loop',
+          title: 'Ship the launch button',
+          spec: { kind: 'goal', text: GOAL_BRIEF, updatedAt: 0 },
+        },
+      )
+
+      expect(result).not.toBeNull()
+      expect(result!.loopName).toBe('ship-the-launch-button-1')
+      const createArgs = mockApi.client.experimental.workspace.create.mock.calls[0][0]
+      expect(createArgs.extra.loopName).toBe('ship-the-launch-button-1')
+      expect(createArgs.extra.forgeLoop.kind).toBe('goal')
+    })
+
+    test('goal + execute-here returns error and performs no provisioning', async () => {
+      const client = await connectForgeProject(mockApi, DIRECTORY)
+      expect(client).not.toBeNull()
+
+      const result = await client!.plan.execute(
+        SESSION_ID,
+        {
+          mode: 'execute-here',
+          title: 'Ship the launch button',
+          spec: { kind: 'goal', text: GOAL_BRIEF, updatedAt: 0 },
+        },
+      )
+
+      expect(result).toEqual({ error: 'Goal briefs can only run as a Loop' })
+      expect(mockApi.client.experimental.workspace.create).not.toHaveBeenCalled()
+      expect(mockApi.client.session.create).not.toHaveBeenCalled()
+      expect(mockApi.client.session.promptAsync).not.toHaveBeenCalled()
+    })
+
+    test('goal + new-session returns error and performs no provisioning', async () => {
+      const client = await connectForgeProject(mockApi, DIRECTORY)
+      expect(client).not.toBeNull()
+
+      const result = await client!.plan.execute(
+        SESSION_ID,
+        {
+          mode: 'new-session',
+          title: 'Ship the launch button',
+          spec: { kind: 'goal', text: GOAL_BRIEF, updatedAt: 0 },
+        },
+      )
+
+      expect(result).toEqual({ error: 'Goal briefs can only run as a Loop' })
+      expect(mockApi.client.experimental.workspace.create).not.toHaveBeenCalled()
+      expect(mockApi.client.session.create).not.toHaveBeenCalled()
+      expect(mockApi.client.session.promptAsync).not.toHaveBeenCalled()
+    })
+  })
 })
diff --git a/test/utils/tui-remote-launch.test.ts b/test/utils/tui-remote-launch.test.ts
index 5276599d4..a9271e0d6 100644
--- a/test/utils/tui-remote-launch.test.ts
+++ b/test/utils/tui-remote-launch.test.ts
@@ -107,6 +107,28 @@ beforeEach(() => {
 })
 
 describe('executeRemoteLoop', () => {
+  test('rejects goal briefs before remote discovery or git operations', async () => {
+    const git = happyGit()
+    const createClient = vi.fn()
+
+    const result = await executeRemoteLoop(
+      {
+        remoteName: 'server1',
+        localDirectory: LOCAL_DIR,
+        localProjectId: LOCAL_PROJECT_ID,
+        title: 'Test Goal',
+        loopName: 'test-goal',
+        spec: { kind: 'goal', text: '## Goal\nDo work.', updatedAt: 0 },
+      },
+      { config: happyConfig(), git, createClient: createClient as any },
+    )
+
+    expect(result).toEqual({ error: 'Remote targets support plans only' })
+    expect(createClient).not.toHaveBeenCalled()
+    expect(git.isInsideWorkTree).not.toHaveBeenCalled()
+    expect(git.push).not.toHaveBeenCalled()
+  })
+
   // ── Happy path ──────────────────────────────────────────────────────────
 
   test('happy path: clean local repo pushes and launches remote loop', async () => {
@@ -123,7 +145,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test Plan',
         loopName: 'test-loop',
-        plan: '# Test Plan\n\nDo work.',
+        spec: { kind: 'plan', text: '# Test Plan\n\nDo work.', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any, onWarning, debug },
     )
@@ -202,7 +224,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -234,7 +256,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -270,7 +292,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -306,7 +328,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -352,7 +374,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -381,7 +403,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: '',
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -421,7 +443,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test',
         loopName: 'loop',
-        plan: 'plan',
+        spec: { kind: 'plan', text: 'plan', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
@@ -458,7 +480,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test Plan',
         loopName: 'test-loop',
-        plan: '# Test Plan\n\nDo work.',
+        spec: { kind: 'plan', text: '# Test Plan\n\nDo work.', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any, onWarning },
     )
@@ -506,7 +528,7 @@ describe('executeRemoteLoop', () => {
         localProjectId: LOCAL_PROJECT_ID,
         title: 'Test Plan',
         loopName: 'test-loop',
-        plan: '# Test Plan\n\nDo work.',
+        spec: { kind: 'plan', text: '# Test Plan\n\nDo work.', updatedAt: 0 },
       },
       { config, git, createClient: createClient as any },
     )
diff --git a/test/utils/tui-stored-plan.test.ts b/test/utils/tui-stored-plan.test.ts
index 79afc1231..45008a841 100644
--- a/test/utils/tui-stored-plan.test.ts
+++ b/test/utils/tui-stored-plan.test.ts
@@ -1,7 +1,8 @@
 import { describe, test, expect } from 'vitest'
 import { openForgeDatabase } from '../../src/storage/database'
 import { createPlansRepo } from '../../src/storage/repos/plans-repo'
-import { fetchStoredSessionPlan } from '../../src/utils/tui-loop-store'
+import { createGoalBriefsRepo } from '../../src/storage/repos/goal-briefs-repo'
+import { fetchStoredSessionLaunchSpec } from '../../src/utils/tui-loop-store'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import { randomUUID } from 'crypto'
@@ -13,39 +14,177 @@ function makeDbPath(): string {
 const PROJECT_ID = 'proj-tui-stored-plan'
 const SESSION_ID = 'sess-tui-stored-plan'
 
-describe('fetchStoredSessionPlan', () => {
-  test('returns stored content written via plans repo', () => {
+function setPlanUpdatedAt(db: import('bun:sqlite').Database, projectId: string, sessionId: string, ts: number): void {
+  db.run('UPDATE plans SET updated_at = ? WHERE project_id = ? AND session_id = ?', [ts, projectId, sessionId])
+}
+
+function setGoalUpdatedAt(db: import('bun:sqlite').Database, projectId: string, sessionId: string, ts: number): void {
+  db.run('UPDATE goal_briefs SET updated_at = ? WHERE project_id = ? AND session_id = ?', [ts, projectId, sessionId])
+}
+
+describe('fetchStoredSessionLaunchSpec', () => {
+  test('returns { kind: plan } for stored plan content', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Plan\n## Section 1')
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result).toEqual({ kind: 'plan', text: '# Plan\n## Section 1', updatedAt: expect.any(Number) })
+  })
+
+  test('returns a stored plan when the database predates goal_briefs', () => {
     const dbPath = makeDbPath()
     const db = openForgeDatabase(dbPath)
     try {
-      const plansRepo = createPlansRepo(db)
-      plansRepo.writeForSession(PROJECT_ID, SESSION_ID, '# Plan\n## Section 1')
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Legacy Plan')
+      db.run('DROP TABLE goal_briefs')
       db.close()
     } catch (err) {
       db.close()
       throw err
     }
 
-    expect(fetchStoredSessionPlan(PROJECT_ID, SESSION_ID, dbPath)).toBe('# Plan\n## Section 1')
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)).toEqual({
+      kind: 'plan',
+      text: '# Legacy Plan',
+      updatedAt: expect.any(Number),
+    })
+  })
+
+  test('returns { kind: goal } when only a goal brief exists', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Goal Brief\n## Goal\nDo the thing')
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result?.kind).toBe('goal')
+    expect(result?.text).toBe('# Goal Brief\n## Goal\nDo the thing')
   })
 
   test('returns null for an unknown session', () => {
     const dbPath = makeDbPath()
     const db = openForgeDatabase(dbPath)
     try {
-      const plansRepo = createPlansRepo(db)
-      plansRepo.writeForSession(PROJECT_ID, SESSION_ID, '# Plan')
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Plan')
       db.close()
     } catch (err) {
       db.close()
       throw err
     }
 
-    expect(fetchStoredSessionPlan(PROJECT_ID, 'sess-other', dbPath)).toBeNull()
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, 'sess-other', dbPath)).toBeNull()
+  })
+
+  test('returns null when neither artifact exists', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    db.close()
+
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)).toBeNull()
   })
 
   test('returns null when the database file does not exist', () => {
     const missingPath = join(tmpdir(), `forge-tui-stored-plan-missing-${randomUUID()}.db`)
-    expect(fetchStoredSessionPlan(PROJECT_ID, SESSION_ID, missingPath)).toBeNull()
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, missingPath)).toBeNull()
+  })
+
+  test('returns the goal brief when both exist and the goal was written later', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Plan')
+      setPlanUpdatedAt(db, PROJECT_ID, SESSION_ID, 1000)
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Goal Brief\n## Goal\nLater')
+      setGoalUpdatedAt(db, PROJECT_ID, SESSION_ID, 2000)
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result?.kind).toBe('goal')
+    expect(result?.updatedAt).toBe(2000)
+  })
+
+  test('returns the plan when both exist and the plan was written later', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Goal Brief\n## Goal\nFirst')
+      setGoalUpdatedAt(db, PROJECT_ID, SESSION_ID, 1000)
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Plan')
+      setPlanUpdatedAt(db, PROJECT_ID, SESSION_ID, 2000)
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result?.kind).toBe('plan')
+    expect(result?.updatedAt).toBe(2000)
+  })
+
+  test('plan wins on an exact updatedAt tie', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Plan')
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Goal Brief\n## Goal\nTie')
+      setPlanUpdatedAt(db, PROJECT_ID, SESSION_ID, 5000)
+      setGoalUpdatedAt(db, PROJECT_ID, SESSION_ID, 5000)
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result?.kind).toBe('plan')
+    expect(result?.updatedAt).toBe(5000)
+  })
+
+  test('treats whitespace-only content as absent', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '   \n\t  ')
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, ' \n ')
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    expect(fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)).toBeNull()
+  })
+
+  test('ignores a blank plan row but returns a present goal brief', () => {
+    const dbPath = makeDbPath()
+    const db = openForgeDatabase(dbPath)
+    try {
+      createPlansRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '   ')
+      createGoalBriefsRepo(db).writeForSession(PROJECT_ID, SESSION_ID, '# Goal Brief\n## Goal\nReal')
+      db.close()
+    } catch (err) {
+      db.close()
+      throw err
+    }
+
+    const result = fetchStoredSessionLaunchSpec(PROJECT_ID, SESSION_ID, dbPath)
+    expect(result?.kind).toBe('goal')
   })
 })