diff --git a/README.md b/README.md
index aa8a3048..f81b8f9a 100644
--- a/README.md
+++ b/README.md
@@ -207,6 +207,7 @@ CopilotKit SDK telemetry collects usage metadata separately from conversation pe
 | Slack                      | Managed Channels SDK declaration with workspace and user allowlists                                                                     |
 | Calls                      | WebRTC speech, delegated compute, bounded sessions, hangup, and timeline receipts                                                       |
 | Background work            | Scheduled server-side turns in their original conversation, with pause and retry controls                                               |
+| Goals and reminders        | SQLite-backed responsibilities, editable progress and status, and one dismissible one-time reminder per goal                            |
 | Browser                    | Separate read-only public-page service with page capture and navigation limits                                                          |
 | Dot computers              | Per-Dot browser profiles, files, shell, takeover, permissions, and action records through OpenBot                                       |
 | Connections                | Per-Dot MCP servers, Composio connected apps, per-tool access, and owner approval for MCP write actions                                 |
@@ -221,13 +222,13 @@ Local checks cover setup, persistence, permissions, SDK failure handling, and br
 
 Automatic Learning routing and skill delivery are configured locally. Cloud schedules, eligible-thread counts, and published-skill delivery still need connected-service verification. Skills require review and publication in Intelligence; existing conversations without a container are not enrolled retroactively.
 
-This is a single-owner starting point. Shared editing, invitations, file uploads, and interactive page embeds are not included. Schedules are recurring instructions, not a complete goal or event-trigger system. Specialist Dots have separate roles and conversations; multi-Dot group conversations and automatic delegation are further work.
+This is a single-owner starting point. Shared editing, invitations, file uploads, and interactive page embeds are not included. Goals and their one-time reminders are managed in the workspace; due reminders appear there for the owner to dismiss, and do not send external notifications or trigger agent work. Recurring schedules remain a separate feature. Specialist Dots have separate roles and conversations; multi-Dot group conversations and automatic delegation are further work.
 
 ### Extending the template
 
 - Add identity, Space membership, and shared page editing for multi-user deployments.
 - Add file attachments and richer page content.
-- Add event triggers and a persistent responsibility lifecycle.
+- Add optional notification delivery for reminders with explicit provider setup and owner controls.
 - Extend tools and approval flows for your own workflows.
 - Add richer artifacts, connected-app context, and specialist coordination.
 
diff --git a/docs/SETUP.md b/docs/SETUP.md
index 80b0c40d..63342e2c 100644
--- a/docs/SETUP.md
+++ b/docs/SETUP.md
@@ -1,6 +1,6 @@
 # Running the template
 
-OpenDots runs a React app and a Node server. The server stores pages, Space and Dot configuration, and thread bindings in SQLite and connects to your configured conversation, model, and messaging services.
+OpenDots runs a React app and a Node server. The server stores pages, Space and Dot configuration, thread bindings, goals, and reminder state in SQLite and connects to your configured conversation, model, and messaging services.
 
 ## Local development
 
@@ -97,6 +97,12 @@ Use the conversation's save-to-page action to create a document from its saved t
 
 Back up both storage layers: SQLite contains page content and thread bindings; the Intelligence project contains conversation history. The template does not include multi-user page sharing, realtime collaboration, file uploads, or arbitrary interactive embeds.
 
+## Goals and reminders
+
+Open **Goals & reminders** in the workspace to create responsibilities, add notes, track progress from 0–100%, and set a one-time reminder. Edit a goal to change its status (active, paused, completed, or cancelled), progress, or reminder time. When an active or paused goal's reminder becomes due, it is highlighted in the workspace; dismissing it is persisted. Changing or clearing the reminder resets its dismissed state.
+
+Goals and reminder timestamps are stored in the configured SQLite database and survive server restarts. They are separate from recurring scheduled turns. Due reminders are only shown in the app while it is open; OpenDots does not send email, push, Slack, or other external notifications for them and does not start agent work when they become due.
+
 ## Browser tool
 
 Parallel is selected by default (`WEB_SEARCH_PROVIDER=parallel`). Live research needs the model configuration, but no browser worker. An optional server-side `PARALLEL_API_KEY` enables authenticated usage and higher limits. The anonymous MCP endpoint is free for light use. Queries, selected URLs, research objectives and a stable session identifier go to Parallel. See [public-web research](../README.md#public-web-research) for data sharing, permissions and limitations.
diff --git a/src/client/App.tsx b/src/client/App.tsx
index e5cc6466..3bed7ed3 100644
--- a/src/client/App.tsx
+++ b/src/client/App.tsx
@@ -20,6 +20,7 @@ import {
   Plus,
   Search,
   Settings2,
+  Target,
   Trash2,
   X,
 } from 'lucide-react';
@@ -46,6 +47,7 @@ import { ThreadList } from './ThreadList';
 import { ResultPane } from './ResultPane';
 import { TaskRow } from './TaskPresentation';
 import { TaskActions } from './TaskActions';
+import { GoalsPanel } from './GoalsPanel';
 import { WorkspaceDialog, type Dialog } from './WorkspaceDialog';
 import { submitComposerOnEnter } from './chat-composer';
 
@@ -62,9 +64,9 @@ export function App() {
   const [workspace, setWorkspace] = useState<WorkspaceState>();
   const [selectedDot, setSelectedDot] = useState('');
   const [selectedThread, setSelectedThread] = useState<string>();
-  const [view, rawSetView] = useState<'chat' | 'tasks' | 'memories' | 'space'>(
-    'chat',
-  );
+  const [view, rawSetView] = useState<
+    'chat' | 'tasks' | 'goals' | 'memories' | 'space'
+  >('chat');
   const dirtyPage = useRef(false);
   const [spaceId, setSpaceId] = useState('');
   const [pageId, setPageId] = useState<string>();
@@ -472,6 +474,17 @@ export function App() {
           </div>
         )}
         <div className="sidebar-bottom">
+          <button
+            className={`nav-item ${view === 'goals' ? 'active' : ''}`}
+            onClick={() => {
+              setView('goals');
+              setMobile(false);
+            }}
+          >
+            <Target size={17} />
+            <span>Goals & reminders</span>
+            {state.goals.length > 0 && <small>{state.goals.length}</small>}
+          </button>
           <button
             className={`nav-item ${view === 'tasks' ? 'active' : ''}`}
             onClick={() => {
@@ -539,9 +552,11 @@ export function App() {
                 ? dot.name
                 : view === 'tasks'
                   ? 'Activity'
-                  : view === 'space'
-                    ? 'Pages'
-                    : 'Memories'}
+                  : view === 'goals'
+                    ? 'Goals & reminders'
+                    : view === 'space'
+                      ? 'Pages'
+                      : 'Memories'}
             </strong>
           </div>
           <div className="top-actions">
@@ -775,12 +790,16 @@ export function App() {
                 <h1>
                   {view === 'memories'
                     ? 'Memories'
-                    : 'A little follow-through.'}
+                    : view === 'goals'
+                      ? 'Goals & reminders'
+                      : 'A little follow-through.'}
                 </h1>
                 <p>
                   {view === 'memories'
                     ? 'Preferences you choose to share with your Dots.'
-                    : 'Scheduled turns run on the server in their original conversation.'}
+                    : view === 'goals'
+                      ? 'Keep responsibilities, progress, and one-time reminders in your workspace.'
+                      : 'Scheduled turns run on the server in their original conversation.'}
                 </p>
               </div>
               {view === 'memories' && (
@@ -793,7 +812,9 @@ export function App() {
                 </button>
               )}
             </div>
-            {view === 'memories' ? (
+            {view === 'goals' ? (
+              <GoalsPanel goals={state.goals} mutate={mutate} />
+            ) : view === 'memories' ? (
               <>
                 <div className="memory-grid">
                   {state.memories.map((memory) => (
diff --git a/src/client/GoalsPanel.tsx b/src/client/GoalsPanel.tsx
new file mode 100644
index 00000000..46c5b7e4
--- /dev/null
+++ b/src/client/GoalsPanel.tsx
@@ -0,0 +1,358 @@
+import { useState, type FormEvent } from 'react';
+import {
+  BellOff,
+  CalendarClock,
+  Check,
+  Circle,
+  Pencil,
+  Plus,
+  Trash2,
+} from 'lucide-react';
+import type { Goal, GoalStatus } from '../shared/types';
+
+type Draft = Pick<Goal, 'title' | 'description' | 'status' | 'progress'> & {
+  reminder: string;
+};
+
+const toLocalInput = (timestamp: number | null) => {
+  if (timestamp === null) return '';
+  const local = new Date(
+    timestamp - new Date(timestamp).getTimezoneOffset() * 60_000,
+  );
+  return local.toISOString().slice(0, 16);
+};
+
+const fromLocalInput = (value: string) => (value ? Date.parse(value) : null);
+
+function reminderText(goal: Goal, now: number) {
+  if (goal.reminderAt === null) return 'No reminder';
+  if (goal.reminderDismissedAt !== null) return 'Reminder dismissed';
+  if (goal.status === 'completed' || goal.status === 'cancelled')
+    return `Reminder inactive (${goal.status})`;
+  if (
+    goal.reminderAt <= now &&
+    (goal.status === 'active' || goal.status === 'paused')
+  )
+    return 'Reminder due';
+  return `Reminder ${new Date(goal.reminderAt).toLocaleString()}`;
+}
+
+export function GoalsPanel({
+  goals,
+  mutate,
+}: {
+  goals: Goal[];
+  mutate: (path: string, method: string, body?: unknown) => Promise<boolean>;
+}) {
+  const [title, setTitle] = useState('');
+  const [description, setDescription] = useState('');
+  const [reminder, setReminder] = useState('');
+  const [editing, setEditing] = useState<string>();
+  const [draft, setDraft] = useState<Draft>();
+  const [search, setSearch] = useState('');
+  const [dateError, setDateError] = useState('');
+
+  const createGoal = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    const reminderAt = fromLocalInput(reminder);
+    if (reminder && !Number.isFinite(reminderAt)) {
+      setDateError('Choose a valid reminder time.');
+      return;
+    }
+    if (
+      await mutate('/goals', 'POST', {
+        title,
+        description,
+        reminderAt,
+      })
+    ) {
+      setTitle('');
+      setDescription('');
+      setReminder('');
+      setDateError('');
+    }
+  };
+
+  const saveGoal = async (event: FormEvent<HTMLFormElement>, id: string) => {
+    event.preventDefault();
+    if (!draft) return;
+    const reminderAt = fromLocalInput(draft.reminder);
+    if (draft.reminder && !Number.isFinite(reminderAt)) {
+      setDateError('Choose a valid reminder time.');
+      return;
+    }
+    if (
+      await mutate(`/goals/${id}`, 'PUT', {
+        title: draft.title,
+        description: draft.description,
+        status: draft.status,
+        progress: draft.progress,
+        reminderAt,
+      })
+    ) {
+      setEditing(undefined);
+      setDraft(undefined);
+      setDateError('');
+    }
+  };
+
+  const beginEdit = (goal: Goal) => {
+    setEditing(goal.id);
+    setDraft({
+      title: goal.title,
+      description: goal.description,
+      status: goal.status,
+      progress: goal.progress,
+      reminder: toLocalInput(goal.reminderAt),
+    });
+  };
+  const visibleGoals = goals.filter((goal) =>
+    `${goal.title} ${goal.description}`
+      .toLowerCase()
+      .includes(search.toLowerCase()),
+  );
+
+  return (
+    <div className="goals-panel">
+      <form
+        className="goal-create"
+        onSubmit={(event) => void createGoal(event)}
+      >
+        <label>
+          Goal or responsibility
+          <input
+            aria-label="Goal or responsibility"
+            value={title}
+            maxLength={120}
+            onChange={(event) => setTitle(event.target.value)}
+            placeholder="e.g. Prepare for the product launch"
+            required
+          />
+        </label>
+        <label>
+          Notes
+          <textarea
+            aria-label="Goal notes"
+            value={description}
+            maxLength={4000}
+            onChange={(event) => setDescription(event.target.value)}
+            placeholder="What does success look like?"
+            rows={2}
+          />
+        </label>
+        <label>
+          Remind me at
+          <input
+            aria-label="Reminder time"
+            type="datetime-local"
+            value={reminder}
+            onChange={(event) => setReminder(event.target.value)}
+          />
+        </label>
+        <button className="primary" type="submit">
+          <Plus size={15} />
+          Add goal
+        </button>
+      </form>
+      {dateError && (
+        <p className="chat-error goal-input-error" role="alert">
+          {dateError}
+        </p>
+      )}
+
+      <label className="search-box">
+        <input
+          aria-label="Search goals"
+          placeholder="Find a goal…"
+          value={search}
+          onChange={(event) => setSearch(event.target.value)}
+        />
+      </label>
+      <div className="goal-list">
+        {visibleGoals.map((goal) => {
+          const isDue =
+            goal.reminderAt !== null &&
+            goal.reminderAt <= Date.now() &&
+            goal.reminderDismissedAt === null &&
+            (goal.status === 'active' || goal.status === 'paused');
+          const isEditing = editing === goal.id && draft;
+          return (
+            <article
+              className={`goal-card ${isDue ? 'is-due' : ''}`}
+              key={goal.id}
+            >
+              {isEditing ? (
+                <form
+                  onSubmit={(event) => void saveGoal(event, goal.id)}
+                  className="goal-edit"
+                >
+                  <label>
+                    Title
+                    <input
+                      value={draft.title}
+                      maxLength={120}
+                      onChange={(event) =>
+                        setDraft({ ...draft, title: event.target.value })
+                      }
+                      required
+                    />
+                  </label>
+                  <label>
+                    Notes
+                    <textarea
+                      value={draft.description}
+                      maxLength={4000}
+                      rows={3}
+                      onChange={(event) =>
+                        setDraft({ ...draft, description: event.target.value })
+                      }
+                    />
+                  </label>
+                  <div className="goal-edit-row">
+                    <label>
+                      Status
+                      <select
+                        value={draft.status}
+                        onChange={(event) =>
+                          setDraft({
+                            ...draft,
+                            status: event.target.value as GoalStatus,
+                          })
+                        }
+                      >
+                        <option value="active">Active</option>
+                        <option value="paused">Paused</option>
+                        <option value="completed">Completed</option>
+                        <option value="cancelled">Cancelled</option>
+                      </select>
+                    </label>
+                    <label>
+                      Progress ({draft.progress}%)
+                      <input
+                        type="range"
+                        min="0"
+                        max="100"
+                        value={draft.progress}
+                        onChange={(event) =>
+                          setDraft({
+                            ...draft,
+                            progress: Number(event.target.value),
+                          })
+                        }
+                      />
+                    </label>
+                  </div>
+                  <label>
+                    Remind me at
+                    <input
+                      type="datetime-local"
+                      value={draft.reminder}
+                      onChange={(event) =>
+                        setDraft({ ...draft, reminder: event.target.value })
+                      }
+                    />
+                  </label>
+                  <div className="goal-card-actions">
+                    <button className="primary" type="submit">
+                      Save changes
+                    </button>
+                    <button
+                      type="button"
+                      onClick={() => {
+                        setEditing(undefined);
+                        setDraft(undefined);
+                      }}
+                    >
+                      Cancel
+                    </button>
+                  </div>
+                </form>
+              ) : (
+                <>
+                  <div className="goal-card-heading">
+                    <span className={`goal-status ${goal.status}`}>
+                      {goal.status === 'completed' ? (
+                        <Check size={14} />
+                      ) : (
+                        <Circle size={12} />
+                      )}
+                      {goal.status}
+                    </span>
+                    <div className="goal-card-actions">
+                      <button
+                        type="button"
+                        aria-label={`Edit ${goal.title}`}
+                        onClick={() => beginEdit(goal)}
+                      >
+                        <Pencil size={15} />
+                      </button>
+                      <button
+                        type="button"
+                        aria-label={`Delete ${goal.title}`}
+                        onClick={() =>
+                          void mutate(`/goals/${goal.id}`, 'DELETE', {})
+                        }
+                      >
+                        <Trash2 size={15} />
+                      </button>
+                    </div>
+                  </div>
+                  <h2>{goal.title}</h2>
+                  {goal.description && <p>{goal.description}</p>}
+                  <div className="goal-progress">
+                    <div
+                      role="progressbar"
+                      aria-label={`${goal.title} progress`}
+                      aria-valuemin={0}
+                      aria-valuemax={100}
+                      aria-valuenow={goal.progress}
+                    >
+                      <span style={{ width: `${goal.progress}%` }} />
+                    </div>
+                    <small>{goal.progress}%</small>
+                  </div>
+                  <div className={`goal-reminder ${isDue ? 'due' : ''}`}>
+                    <CalendarClock size={15} />
+                    <span>{reminderText(goal, Date.now())}</span>
+                    {isDue && (
+                      <button
+                        type="button"
+                        onClick={() =>
+                          void mutate(
+                            `/goals/${goal.id}/reminder/dismiss`,
+                            'POST',
+                          )
+                        }
+                      >
+                        <BellOff size={14} />
+                        Dismiss
+                      </button>
+                    )}
+                  </div>
+                  <small className="goal-updated">
+                    Updated {new Date(goal.updatedAt).toLocaleDateString()}
+                  </small>
+                </>
+              )}
+            </article>
+          );
+        })}
+      </div>
+      {!visibleGoals.length && (
+        <div className="large-empty">
+          <CalendarClock size={32} />
+          <h2>
+            {goals.length
+              ? 'No matching goals.'
+              : 'Make space for follow-through.'}
+          </h2>
+          <p>
+            {goals.length
+              ? 'Try another search.'
+              : 'Track a responsibility, update progress, and add a private reminder that stays on this server.'}
+          </p>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/client/style.css b/src/client/style.css
index 75be32de..afcdb80a 100644
--- a/src/client/style.css
+++ b/src/client/style.css
@@ -836,6 +836,205 @@ h3 {
   font-size: 9px;
   margin-right: auto;
 }
+.goals-panel {
+  max-width: 1040px;
+}
+.goal-create {
+  display: grid;
+  grid-template-columns: 1.2fr 1.5fr 1fr auto;
+  align-items: end;
+  gap: 12px;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  padding: 16px;
+  margin-bottom: 24px;
+}
+.goal-create label,
+.goal-edit label {
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+  color: #737783;
+  font-size: 10px;
+}
+.goal-create input,
+.goal-create textarea,
+.goal-edit input:not([type='range']),
+.goal-edit textarea,
+.goal-edit select {
+  width: 100%;
+  min-width: 0;
+  border: 1px solid #e8e8ed;
+  border-radius: 7px;
+  background: #fff;
+  padding: 10px;
+  color: #454955;
+  font: inherit;
+  font-size: 11px;
+}
+.goal-create textarea,
+.goal-edit textarea {
+  resize: vertical;
+}
+.goal-create .primary,
+.goal-card-actions .primary {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  white-space: nowrap;
+}
+.goal-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(270px, 1fr));
+  gap: 13px;
+}
+.goal-card {
+  min-width: 0;
+  background: #fff;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  padding: 17px;
+}
+.goal-card.is-due {
+  border-color: #dfb5a9;
+  box-shadow: 0 0 0 2px #faeee9;
+}
+.goal-card-heading,
+.goal-card-actions,
+.goal-edit-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 9px;
+}
+.goal-card-actions button {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border: 0;
+  background: #f7f7f9;
+  color: #858895;
+  border-radius: 6px;
+  padding: 7px;
+  font-size: 10px;
+}
+.goal-card h2 {
+  margin: 15px 0 8px;
+  font-size: 16px;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+.goal-card > p {
+  color: #878a96;
+  font-size: 11px;
+  line-height: 1.75;
+  white-space: pre-wrap;
+}
+.goal-status {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border-radius: 5px;
+  padding: 5px 7px;
+  background: #f2f3f5;
+  color: #818590;
+  font-size: 9px;
+  text-transform: capitalize;
+}
+.goal-status.active {
+  background: #edf5ee;
+  color: #79957e;
+}
+.goal-status.paused {
+  background: #f7f3eb;
+  color: #a38e69;
+}
+.goal-status.completed {
+  background: #edf0f9;
+  color: #788bc3;
+}
+.goal-progress {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  margin: 16px 0;
+}
+.goal-progress > div {
+  height: 6px;
+  flex: 1;
+  overflow: hidden;
+  border-radius: 5px;
+  background: #eff0f3;
+}
+.goal-progress > div span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: #75b9b4;
+}
+.goal-progress small,
+.goal-updated {
+  color: #9a9ca7;
+  font-size: 9px;
+}
+.goal-reminder {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  min-height: 35px;
+  padding: 7px 9px;
+  border-radius: 7px;
+  background: #f6f6f8;
+  color: #858894;
+  font-size: 10px;
+}
+.goal-reminder.due {
+  background: #faeee9;
+  color: #a96553;
+}
+.goal-reminder button {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  margin-left: auto;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font-size: 9px;
+}
+.goal-updated {
+  display: block;
+  margin-top: 13px;
+}
+.goal-edit {
+  display: flex;
+  flex-direction: column;
+  gap: 13px;
+}
+.goal-edit-row > label {
+  min-width: 0;
+  flex: 1;
+}
+.goal-edit input[type='range'] {
+  width: 100%;
+  accent-color: #75b9b4;
+}
+.goal-card-actions {
+  justify-content: flex-start;
+}
+.goal-card-actions button:not(.primary) {
+  padding: 9px 10px;
+}
+@media (max-width: 760px) {
+  .goal-create {
+    grid-template-columns: 1fr;
+  }
+  .goal-create .primary {
+    justify-self: start;
+  }
+}
 .notice {
   background: #f3eee4;
   padding: 12px 40px;
diff --git a/src/server/app.ts b/src/server/app.ts
index fe34b0c8..52c21bc8 100644
--- a/src/server/app.ts
+++ b/src/server/app.ts
@@ -102,6 +102,7 @@ export function createApp({
     c.json({
       settings: store.settings(),
       tasks: store.tasks(),
+      goals: store.goals(),
       memories: store.memories(),
       mode: config.mode,
       configured: configured(config),
@@ -239,6 +240,47 @@ export function createApp({
       ? c.json({ ok: true })
       : c.json({ error: 'Memory not found.' }, 404),
   );
+  const goalFields = {
+    title: z.string().trim().min(1).max(120),
+    description: z.string().trim().max(4000),
+    status: z.enum(['active', 'paused', 'completed', 'cancelled']),
+    progress: z.number().int().min(0).max(100),
+    reminderAt: z.number().int().min(1).max(8_640_000_000_000_000).nullable(),
+  };
+  app.post('/api/goals', async (c) => {
+    const parsed = z
+      .object({
+        title: goalFields.title,
+        description: goalFields.description.optional().default(''),
+        status: goalFields.status.optional().default('active'),
+        progress: goalFields.progress.optional().default(0),
+        reminderAt: goalFields.reminderAt.optional().default(null),
+      })
+      .strict()
+      .safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success)
+      return c.json({ error: 'Enter valid goal details.' }, 400);
+    return c.json(store.createGoal(parsed.data), 201);
+  });
+  app.put('/api/goals/:id', async (c) => {
+    const parsed = z
+      .object(goalFields)
+      .strict()
+      .safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success)
+      return c.json({ error: 'Enter valid goal details.' }, 400);
+    const goal = store.updateGoal(c.req.param('id'), parsed.data);
+    return goal ? c.json(goal) : c.json({ error: 'Goal not found.' }, 404);
+  });
+  app.post('/api/goals/:id/reminder/dismiss', (c) => {
+    const goal = store.dismissGoalReminder(c.req.param('id'));
+    return goal ? c.json(goal) : c.json({ error: 'Goal not found.' }, 404);
+  });
+  app.delete('/api/goals/:id', (c) =>
+    store.deleteGoal(c.req.param('id'))
+      ? c.json({ ok: true })
+      : c.json({ error: 'Goal not found.' }, 404),
+  );
   app.onError((error, c) => {
     console.error('API request failed:', error.name);
     return c.json(
diff --git a/src/server/store.ts b/src/server/store.ts
index 05d7d86a..677894b2 100644
--- a/src/server/store.ts
+++ b/src/server/store.ts
@@ -5,6 +5,8 @@ import { dirname } from 'node:path';
 import type {
   Action,
   Detail,
+  Goal,
+  GoalStatus,
   Memory,
   Result,
   Run,
@@ -33,10 +35,12 @@ export class Store {
       CREATE TABLE IF NOT EXISTS tasks (id TEXT PRIMARY KEY, prompt TEXT NOT NULL, status TEXT NOT NULL, intervalSeconds INTEGER, nextRunAt INTEGER, createdAt INTEGER NOT NULL, updatedAt INTEGER NOT NULL, error TEXT, lease TEXT, leaseUntil INTEGER);
       CREATE TABLE IF NOT EXISTS runs (id TEXT PRIMARY KEY, taskId TEXT NOT NULL, status TEXT NOT NULL, startedAt INTEGER NOT NULL, finishedAt INTEGER, result TEXT, error TEXT);
       CREATE TABLE IF NOT EXISTS events (id INTEGER PRIMARY KEY AUTOINCREMENT, taskId TEXT NOT NULL, runId TEXT, text TEXT NOT NULL, createdAt INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS goals (id TEXT PRIMARY KEY, title TEXT NOT NULL, description TEXT NOT NULL, status TEXT NOT NULL, progress INTEGER NOT NULL, reminderAt INTEGER, reminderDismissedAt INTEGER, createdAt INTEGER NOT NULL, updatedAt INTEGER NOT NULL);
       CREATE TABLE IF NOT EXISTS memories (id TEXT PRIMARY KEY, text TEXT NOT NULL, createdAt INTEGER NOT NULL);
       CREATE INDEX IF NOT EXISTS tasks_due ON tasks(status, nextRunAt);
       CREATE INDEX IF NOT EXISTS runs_task ON runs(taskId, startedAt);
-      CREATE INDEX IF NOT EXISTS events_task ON events(taskId, id);`);
+      CREATE INDEX IF NOT EXISTS events_task ON events(taskId, id);
+      CREATE INDEX IF NOT EXISTS goals_updated ON goals(updatedAt DESC);`);
     this.db
       .prepare('INSERT OR IGNORE INTO settings VALUES (1, ?)')
       .run(JSON.stringify(defaults));
@@ -316,4 +320,85 @@ export class Store {
       this.db.prepare('DELETE FROM memories WHERE id=?').run(id).changes > 0
     );
   }
+  goals(): Goal[] {
+    return this.db
+      .prepare('SELECT * FROM goals ORDER BY updatedAt DESC, createdAt DESC')
+      .all() as unknown as Goal[];
+  }
+  goal(id: string): Goal | undefined {
+    return this.db
+      .prepare('SELECT * FROM goals WHERE id=?')
+      .get(id) as unknown as Goal | undefined;
+  }
+  createGoal(input: {
+    title: string;
+    description: string;
+    status?: GoalStatus;
+    progress?: number;
+    reminderAt?: number | null;
+  }): Goal {
+    const now = Date.now();
+    const id = randomUUID();
+    this.db
+      .prepare('INSERT INTO goals VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)')
+      .run(
+        id,
+        input.title,
+        input.description,
+        input.status ?? 'active',
+        input.progress ?? 0,
+        input.reminderAt ?? null,
+        now,
+        now,
+      );
+    return this.goal(id)!;
+  }
+  updateGoal(
+    id: string,
+    input: {
+      title: string;
+      description: string;
+      status: GoalStatus;
+      progress: number;
+      reminderAt: number | null;
+    },
+  ): Goal | undefined {
+    const existing = this.goal(id);
+    if (!existing) return undefined;
+    const reminderDismissedAt =
+      existing.reminderAt === input.reminderAt
+        ? existing.reminderDismissedAt
+        : null;
+    this.db
+      .prepare(
+        'UPDATE goals SET title=?, description=?, status=?, progress=?, reminderAt=?, reminderDismissedAt=?, updatedAt=? WHERE id=?',
+      )
+      .run(
+        input.title,
+        input.description,
+        input.status,
+        input.progress,
+        input.reminderAt,
+        reminderDismissedAt,
+        Date.now(),
+        id,
+      );
+    return this.goal(id);
+  }
+  dismissGoalReminder(id: string): Goal | undefined {
+    const goal = this.goal(id);
+    if (!goal) return undefined;
+    if (goal.reminderAt !== null && goal.reminderDismissedAt === null) {
+      const now = Date.now();
+      this.db
+        .prepare(
+          'UPDATE goals SET reminderDismissedAt=?, updatedAt=? WHERE id=?',
+        )
+        .run(now, now, id);
+    }
+    return this.goal(id);
+  }
+  deleteGoal(id: string): boolean {
+    return this.db.prepare('DELETE FROM goals WHERE id=?').run(id).changes > 0;
+  }
 }
diff --git a/src/shared/types.ts b/src/shared/types.ts
index 0e1ca6e9..55bad634 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -57,6 +57,18 @@ export interface Memory {
   text: string;
   createdAt: number;
 }
+export type GoalStatus = 'active' | 'paused' | 'completed' | 'cancelled';
+export interface Goal {
+  id: string;
+  title: string;
+  description: string;
+  status: GoalStatus;
+  progress: number;
+  reminderAt: number | null;
+  reminderDismissedAt: number | null;
+  createdAt: number;
+  updatedAt: number;
+}
 export interface Detail {
   task: Task;
   runs: Run[];
@@ -65,6 +77,7 @@ export interface Detail {
 export interface State {
   settings: Settings;
   tasks: Task[];
+  goals: Goal[];
   memories: Memory[];
   mode: 'sample' | 'live';
   configured: boolean;
diff --git a/tests/app.test.ts b/tests/app.test.ts
index 7c493214..eff1452b 100644
--- a/tests/app.test.ts
+++ b/tests/app.test.ts
@@ -254,6 +254,59 @@ describe('API boundaries', () => {
     });
     expect(store.memories()).toHaveLength(0);
   });
+  it('validates, updates, dismisses, and deletes durable goals', async () => {
+    const { app, store } = fixture();
+    const reminderAt = Date.now() + 60_000;
+    const created = await app.request(
+      '/api/goals',
+      json({
+        title: 'Prepare a launch brief',
+        description: 'Collect final notes',
+        reminderAt,
+      }),
+    );
+    expect(created.status).toBe(201);
+    const goal = (await created.json()) as { id: string };
+    expect(store.goal(goal.id)?.status).toBe('active');
+    const state = (await (await app.request('/api/state')).json()) as {
+      goals: { id: string }[];
+    };
+    expect(state.goals[0]?.id).toBe(goal.id);
+    expect(
+      (
+        await app.request(
+          '/api/goals',
+          json({
+            title: 'Invalid progress',
+            progress: 101,
+            reminderAt: Date.now() + 60_000,
+          }),
+        )
+      ).status,
+    ).toBe(400);
+    const update = await app.request(`/api/goals/${goal.id}`, {
+      ...json({
+        title: 'Prepare a launch brief',
+        description: 'Collect final notes',
+        status: 'paused',
+        progress: 45,
+        reminderAt,
+      }),
+      method: 'PUT',
+    });
+    expect(update.status).toBe(200);
+    expect(store.goal(goal.id)?.progress).toBe(45);
+    await app.request(`/api/goals/${goal.id}/reminder/dismiss`, json({}));
+    expect(store.goal(goal.id)?.reminderDismissedAt).not.toBeNull();
+    const deleted = await app.request(`/api/goals/${goal.id}`, {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{}',
+    });
+    expect(deleted.status).toBe(200);
+    expect(store.goal(goal.id)).toBeUndefined();
+    expect((await app.request('/api/state')).status).toBe(200);
+  });
 });
 it('rejects DNS-rebinding Host even with a matching hostile Origin', async () => {
   const { app } = fixture();
diff --git a/tests/goals-panel.test.tsx b/tests/goals-panel.test.tsx
new file mode 100644
index 00000000..d002eb3c
--- /dev/null
+++ b/tests/goals-panel.test.tsx
@@ -0,0 +1,29 @@
+import { renderToStaticMarkup } from 'react-dom/server';
+import { expect, it, vi } from 'vitest';
+import { GoalsPanel } from '../src/client/GoalsPanel';
+
+it('shows a due reminder with progress and a dismiss control', () => {
+  const html = renderToStaticMarkup(
+    <GoalsPanel
+      goals={[
+        {
+          id: 'goal-1',
+          title: 'Prepare a launch brief',
+          description: 'Collect final notes',
+          status: 'active',
+          progress: 62,
+          reminderAt: Date.now() - 60_000,
+          reminderDismissedAt: null,
+          createdAt: Date.now() - 120_000,
+          updatedAt: Date.now(),
+        },
+      ]}
+      mutate={vi.fn(async () => true)}
+    />,
+  );
+
+  expect(html).toContain('Prepare a launch brief');
+  expect(html).toContain('Reminder due');
+  expect(html).toContain('Dismiss');
+  expect(html).toContain('aria-valuenow="62"');
+});
diff --git a/tests/store.test.ts b/tests/store.test.ts
index edb4fa00..ecf0a45a 100644
--- a/tests/store.test.ts
+++ b/tests/store.test.ts
@@ -30,6 +30,44 @@ describe('durable task lifecycle', () => {
     expect(reopened.settings().name).toBe('Sam');
     reopened.close();
   });
+
+  describe('durable goals and reminders', () => {
+    it('persists goals and resets a dismissed reminder when its time changes', () => {
+      const { store, path } = fixture();
+      const reminderAt = Date.now() + 60_000;
+      const created = store.createGoal({
+        title: 'Prepare a launch brief',
+        description: 'Collect the final notes',
+        reminderAt,
+      });
+      expect(
+        store.dismissGoalReminder(created.id)?.reminderDismissedAt,
+      ).not.toBeNull();
+      const updated = store.updateGoal(created.id, {
+        title: created.title,
+        description: created.description,
+        status: 'active',
+        progress: 35,
+        reminderAt: reminderAt + 60_000,
+      });
+      expect(updated?.progress).toBe(35);
+      expect(updated?.reminderDismissedAt).toBeNull();
+
+      const reopened = new Store(path);
+      try {
+        expect(reopened.goal(created.id)).toMatchObject({
+          title: 'Prepare a launch brief',
+          progress: 35,
+          reminderAt: reminderAt + 60_000,
+          reminderDismissedAt: null,
+        });
+        expect(reopened.deleteGoal(created.id)).toBe(true);
+        expect(reopened.goal(created.id)).toBeUndefined();
+      } finally {
+        reopened.close();
+      }
+    });
+  });
   it('claims each due job once even through separate database connections', () => {
     const { store, path } = fixture();
     store.createTask('Research one');