@withbuddi/buddi 0.1.0-pre.18 → 0.1.0-pre.20

package/node_modules/@buddi/gateway/dist/missions/goals.js

@@ -28,10 +28,10 @@
  *    `goal.status`; only the holder may update or close, and a non-holder is
  *    told `not-yours` in as many words, the way `reminder.cancel` does it.
  */
-import { GOAL_CADENCES, MAX_GOAL_TITLE, MAX_MILESTONES, MAX_OPEN_GOALS, assertApprovedEffect, closeGoal, createGoal, getGoal, checkMetricParams, STANDING_CHECKS, lastCheck, lastMeasuredCheck, listGoals, localDateString, measureMetricResult, measuredChecks, metricParamsSchema, milestoneValue, milestonesCrossed, paceNeeded, parseReminderWhen, reached, recentChecks, recordCheck, settleGoal, standingOf, targetValue, updateGoal, } from '@buddi/core';
+import { GOAL_CADENCES, MAX_GOAL_TITLE, MAX_MILESTONES, MAX_OPEN_GOALS, assertApprovedEffect, closeGoal, createGoal, getGoal, checkMetricParams, STANDING_CHECKS, lastCheck, lastMeasuredCheck, listGoals, localDateString, measureMetricResult, measuredChecks, metricParamsSchema, milestoneValue, milestonesCrossed, paceNeeded, parseReminderWhen, reached, recentChecks, recordCheck, settleGoal, standingOf, targetValue, updateGoal, FREQUENCY_PERS, MAX_FREQUENCY_COUNT, frequencySettles, frequencyWords, METRIC_DIRECTIONS, METRIC_UNITS, MAX_OWNER_LABEL, MAX_OWNER_UNIT_LABEL, OWNER_SOURCE, createOwnerMetric, cadenceMs, getOwnerMetric, isOwnerMetric, latestOwnerValue, ownerMetricId, ownerSlugOf, recordOwnerValue, refuseOutsideBand, refuseOwnerSlug, } from '@buddi/core';
 import { z } from 'zod';
-import { GOALS_SENTINEL_ID, checkLines, formatPace, formatValue, goalKey, goalLine } from './goals-format.js';
-import { CHART_CHECKS, chartOf, createGoalHome, createGoalOwnerClose, createGoalQueries, goalViews, goalsPage, } from './goals-page.js';
+import { GOALS_SENTINEL_ID, asOwnerSource, frequencyNow, baseUnit, checkLines, formatPace, formatValue, goalKey, goalLine, unitLabelOf, valueUnitOf, } from './goals-format.js';
+import { CHART_CHECKS, chartOf, createGoalHome, createGoalOwnerClose, createGoalQueries, frequencyOf, goalOwnerValues, goalViews, goalsPage, } from './goals-page.js';
 /** Plugin family name for the goal tools. The rows live in core's schema. */
 export const GOAL_PLUGIN = 'goal';
 /**
@@ -77,6 +77,16 @@ export const GOAL_WAKE_INSTRUCTION = 'Verify with your own tools, then report; t
  * they and this one import is what keeps those two out of a cycle.
  * ------------------------------------------------------------------ */
 export { checkLines, formatPace, formatValue, goalLine } from './goals-format.js';
+export { asOwnerSource } from './goals-format.js';
+/** Where a value was said, from the surface the run answers on. */
+export function valueSourceOf(ctx) {
+    const surface = ctx.surface?.id;
+    if (surface === 'telegram')
+        return 'telegram';
+    if (surface === 'web' || surface === 'cli')
+        return 'chat';
+    return 'api';
+}
 /**
  * The sentence the owner approves.
  *
@@ -105,6 +115,30 @@ export function renderGoalSet(envelope, unit, direction, timezone) {
     const stale = readingAsOf !== null && setAt.getTime() - readingAsOf.getTime() > 24 * 60 * 60_000
         ? ` (reading as of ${localDateString(readingAsOf, timezone)})`
         : '';
+    const measuredBy = envelope.owner !== undefined
+        ? `Measured by you, when you tell buddi${envelope.owner.isNew ? ` (a new metric, ${envelope.metric})` : ''}, until ${localDateString(asGoal.deadline, timezone)}.`
+        : `Measured by ${envelope.metric}${Object.keys(envelope.params).length === 0 ? '' : ` ${JSON.stringify(envelope.params)}`}, every ${envelope.cadence === 'daily' ? 'day' : 'week'}, until ${localDateString(asGoal.deadline, timezone)}.`;
+    if (envelope.target.kind === 'frequency') {
+        /*
+         * "3 times a week until 2026-12-31": a count per window has no "from"
+         * and no pace per week — the window is the pace. Milestones are streaks.
+         */
+        const per = envelope.target.per;
+        const lines = [
+            `${envelope.title}`,
+            '',
+            `${frequencyWords(envelope.target)} until ${localDateString(asGoal.deadline, timezone)}, ` +
+                `checked ${envelope.cadence}, held by @${envelope.agentId}`,
+            '',
+            measuredBy,
+        ];
+        if (envelope.milestones.length > 0) {
+            lines.push(`Milestones you will hear about, once each: ${envelope.milestones
+                .map((m) => `${m} ${per}s in a row`)
+                .join(', ')}.`);
+        }
+        return lines.join('\n');
+    }
     const lines = [
         `${envelope.title}`,
         '',
@@ -112,7 +146,7 @@ export function renderGoalSet(envelope, unit, direction, timezone) {
             `${formatValue(targetValue(asGoal), unit, currency)} by ${localDateString(asGoal.deadline, timezone)}: ` +
             `${formatPace(pace, unit, direction, currency)}, checked ${envelope.cadence}, held by @${envelope.agentId}`,
         '',
-        `Measured by ${envelope.metric}${Object.keys(envelope.params).length === 0 ? '' : ` ${JSON.stringify(envelope.params)}`}, every ${envelope.cadence === 'daily' ? 'day' : 'week'}, until ${localDateString(asGoal.deadline, timezone)}.`,
+        measuredBy,
     ];
     if (envelope.milestones.length > 0) {
         lines.push(`Milestones you will hear about, once each: ${envelope.milestones
@@ -123,10 +157,12 @@ export function renderGoalSet(envelope, unit, direction, timezone) {
 }
 /** The card: one line per field that actually changes, before → after. */
 export function renderGoalUpdate(envelope, unit, timezone, baseline, currency = null) {
-    const value = (target) => formatValue(targetValue({ target, baseline: { value: baseline, asOf: new Date(0) } }), unit, currency);
+    const value = (target) => target.kind === 'frequency'
+        ? frequencyWords(target)
+        : formatValue(targetValue({ target, baseline: { value: baseline, asOf: new Date(0) } }), unit, currency);
     const { before, after } = envelope;
     const rows = [];
-    if (before.target.kind !== after.target.kind || before.target.value !== after.target.value) {
+    if (JSON.stringify(before.target) !== JSON.stringify(after.target)) {
         rows.push(`Target:    ${value(before.target)} → ${value(after.target)}`);
     }
     if (before.deadline !== after.deadline) {
@@ -146,7 +182,7 @@ export function renderGoalUpdate(envelope, unit, timezone, baseline, currency =
 /* ------------------------------------------------------------------ *
  * Inputs
  * ------------------------------------------------------------------ */
-const targetInput = z
+const levelTargetInput = z
     .object({
     kind: z
         .enum(['absolute', 'delta'])
@@ -158,6 +194,42 @@ const targetInput = z
         .describe('The number. For a delta it carries its own sign: -40000 to come down by 40,000.'),
 })
     .strict();
+const frequencyTargetInput = z
+    .object({
+    kind: z
+        .literal('frequency')
+        .describe('"run three times a week": how many values the owner reports in every week or month.'),
+    count: z.number().int().min(1).max(MAX_FREQUENCY_COUNT).describe('How many times in each window: 3.'),
+    per: z.enum(FREQUENCY_PERS).describe('The window: a week (Monday to Sunday) or a calendar month.'),
+})
+    .strict();
+/**
+ * A level target, or a frequency. A frequency goal counts the values of a
+ * metric the owner reports; "finish X by Friday" is neither — that is a
+ * reminder or a mission.
+ */
+const targetInput = z.union([levelTargetInput, frequencyTargetInput]);
+/** A metric the owner will report, named the first time a goal needs it. */
+const ownerMetricInput = z
+    .object({
+    slug: z
+        .string()
+        .min(1)
+        .max(40)
+        .describe('A short kebab name, unique here: "weight", "resting-heart-rate". The metric becomes owner.<slug>.'),
+    label: z.string().min(1).max(MAX_OWNER_LABEL).describe('What it is, in the owner\'s words: "Weight".'),
+    unit: z
+        .enum(METRIC_UNITS)
+        .describe('How the number is formatted. Weight is "number" with a unitLabel; a count of runs is "count".'),
+    direction: z.enum(METRIC_DIRECTIONS).describe('Which way is better: "down" for weight to lose, "up" for runs.'),
+    unitLabel: z
+        .string()
+        .min(1)
+        .max(MAX_OWNER_UNIT_LABEL)
+        .optional()
+        .describe('The word after the number, when there is one: "lb", "kg", "km".'),
+})
+    .strict();
 const setInput = z
     .object({
     title: z
@@ -166,9 +238,16 @@ const setInput = z
         .max(MAX_GOAL_TITLE)
         .describe('A short name the owner will recognise on a card months from now: "Debt down by 40k".'),
     metric: z
-        .string()
-        .min(1)
-        .describe('The namespaced metric to watch, exactly as goal.metrics lists it: "finance.total_debt".'),
+        .union([z.string().min(1), z.object({ owner: ownerMetricInput }).strict()])
+        .describe('The metric to watch: an id exactly as goal.metrics lists it ("finance.total_debt", "owner.weight"), ' +
+        'or, when no metric measures what the owner named, {"owner": {slug, label, unit, direction, unitLabel?}} ' +
+        'to create one the owner reports. Never create an owner metric for something a plugin already measures.'),
+    baseline: z
+        .object({ value: z.number().finite().describe('The number the owner said: "I\'m 288" is 288.') })
+        .strict()
+        .optional()
+        .describe('Only for a metric the owner reports: where they are today, from the sentence that set the goal, so ' +
+        'the goal starts measured. A plugin metric is measured instead.'),
     params: z
         .record(z.unknown())
         .optional()
@@ -188,7 +267,8 @@ const setInput = z
         .max(MAX_MILESTONES)
         .optional()
         .describe('Numbers on the same scale as the target — deltas when the target is a delta — that you want to say ' +
-        'something about when they are crossed. Each fires once, ever.'),
+        'something about when they are crossed. For a frequency goal they are streaks: [4, 8] is four and ' +
+        'eight windows met in a row. Each fires once, ever.'),
 })
     .strict();
 const updateInput = z
@@ -223,7 +303,52 @@ const statusInput = z
         .describe('One goal, by id — any goal, whoever holds it. Leave it out for all of your own.'),
 })
     .strict();
+const recordInput = z
+    .object({
+    goal: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The goal the number is for, by id. Name this or metric, not both.'),
+    metric: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Or the metric the owner reports: "owner.weight", or just "weight".'),
+    value: z.number().finite().describe('The number the owner said. An occurrence ("ran today") is 1.'),
+    asOf: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("When it was true, in the owner's timezone: 2026-09-26 or 2026-09-26T07:30. Leave it out for now."),
+    note: z.string().max(280).optional().describe('A few words the owner added: "after the holidays".'),
+    confirmed: z
+        .boolean()
+        .optional()
+        .describe('Set only after the owner confirmed a value this tool refused as far from the last one.'),
+})
+    .strict();
+/** A conversation id is a uuid; anything else is not provenance worth keeping. */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const refusal = (reason, message) => ({ ok: false, reason, message });
+/**
+ * A frequency goal's milestones are streaks — windows met in a row — so they
+ * are whole numbers from 1 up, listed in the order they will be reached.
+ */
+function refuseStreaks(milestones) {
+    let previous = 0;
+    for (const milestone of milestones) {
+        if (!Number.isInteger(milestone) || milestone <= previous) {
+            return refusal('wrong-direction', `the milestone ${milestone} is not a streak: a frequency goal's milestones are windows met in a row, ` +
+                'whole numbers from 1 up, listed from the smallest ([4, 8]).');
+        }
+        previous = milestone;
+    }
+    return null;
+}
+/** How many owner values and frequency windows `goal.status` prints. */
+export const STATUS_VALUES = 10;
+export const STATUS_WINDOWS = 12;
 /* ------------------------------------------------------------------ *
  * The manifest
  * ------------------------------------------------------------------ */
@@ -234,9 +359,15 @@ const refusal = (reason, message) => ({ ok: false, reason, message });
  * `MetricSource` so a suite can hand it one in-memory metric and exercise the
  * whole surface without building a plugin.
  */
-export function createGoalManifest(source) {
+export function createGoalManifest(base) {
+    /*
+     * The plugin metrics and the owner's, behind one `metric(id)`. Every tool
+     * refreshes its owner half first — one small `select` — so a metric another
+     * conversation created a minute ago is known here.
+     */
+    const source = asOwnerSource(base);
     /** The unit a goal's numbers are rendered in, or a safe default. */
-    const unitOf = (metric) => source.metric(metric)?.unit ?? 'number';
+    const unitOf = (metric) => valueUnitOf(source, metric);
     /** Which way is better, for a goal whose plugin may have been uninstalled. */
     const directionOf = (metric) => source.metric(metric)?.direction ?? 'down';
     /**
@@ -280,15 +411,96 @@ export function createGoalManifest(source) {
         }
         return null;
     }
+    function definitionOf(metric) {
+        return {
+            slug: metric.slug,
+            label: metric.label,
+            unit: metric.unit,
+            direction: metric.direction,
+            unitLabel: metric.unitLabel,
+        };
+    }
+    /**
+     * Which metric this is, or why there is none.
+     *
+     * A string names an installed metric (a plugin's, or an owner metric that
+     * already exists). An `{ owner }` definition names one to create — or one
+     * that exists already, in which case it has to agree about the unit and the
+     * direction: two goals reading one series in opposite directions is a
+     * contradiction, not a second opinion.
+     */
+    async function resolveMetric(input, ctx) {
+        if (typeof input.metric === 'string') {
+            const found = source.metric(input.metric);
+            if (found === undefined) {
+                return refusal('unknown-metric', `no metric "${input.metric}" is installed here. Call goal.metrics and name one of those, or pass ` +
+                    '{"owner": {...}} for a number the owner will report; a goal without a metric is a reminder.');
+            }
+            if (isOwnerMetric(found)) {
+                const slug = ownerSlugOf(found.id);
+                return {
+                    ok: true,
+                    metric: {
+                        id: found.id,
+                        unit: valueUnitOf(source, found.id),
+                        direction: found.direction,
+                        owner: {
+                            metric: { slug, label: found.label, unit: found.unit, direction: found.direction, unitLabel: found.unitLabel },
+                            isNew: false,
+                        },
+                    },
+                };
+            }
+            return { ok: true, metric: { id: found.id, unit: found.unit, direction: found.direction, owner: null } };
+        }
+        const def = input.metric.owner;
+        const badSlug = refuseOwnerSlug(def.slug);
+        if (badSlug !== null)
+            return refusal('invalid-metric', badSlug);
+        const wanted = {
+            slug: def.slug,
+            label: def.label.trim(),
+            unit: def.unit,
+            direction: def.direction,
+            unitLabel: def.unitLabel?.trim() || null,
+        };
+        const existing = await getOwnerMetric(ctx.db, def.slug);
+        if (existing !== null) {
+            if (existing.unit !== wanted.unit ||
+                existing.direction !== wanted.direction ||
+                (existing.unitLabel ?? null) !== wanted.unitLabel) {
+                return refusal('metric-differs', `owner.${def.slug} already exists as ${existing.unit}${existing.unitLabel ? ` (${existing.unitLabel})` : ''}, better ${existing.direction}. Name it as "owner.${def.slug}" to use it, or choose another slug.`);
+            }
+            return {
+                ok: true,
+                metric: {
+                    id: existing.id,
+                    unit: existing.unitLabel ? { unit: existing.unit, label: existing.unitLabel } : existing.unit,
+                    direction: existing.direction,
+                    owner: { metric: definitionOf(existing), isNew: false },
+                },
+            };
+        }
+        return {
+            ok: true,
+            metric: {
+                id: ownerMetricId(def.slug),
+                unit: wanted.unitLabel ? { unit: wanted.unit, label: wanted.unitLabel } : wanted.unit,
+                direction: wanted.direction,
+                owner: { metric: wanted, isNew: true },
+            },
+        };
+    }
     /**
      * Everything `goal.set` refuses before an approval exists, in one place.
      *
      * Read twice on purpose: by `describe`, so the call never becomes a card,
      * and again by `execute`, because the approval was recorded minutes or hours
      * ago and "a delegate may not" is a fact about the run that is executing. It
-     * only reads the arguments and the context, so both readings agree.
+     * only reads the arguments, the context and the metric definitions, so both
+     * readings agree.
      */
-    function refuseSet(input, ctx) {
+    async function refuseSet(input, ctx) {
         if (!ctx.agentId) {
             return refusal('no-agent', 'a goal belongs to the agent that holds it, and this run has no agent id, so there is nobody to hold it');
         }
@@ -296,14 +508,41 @@ export function createGoalManifest(source) {
             return refusal('delegate', 'a delegate cannot set a goal: a goal outlives this run by months and belongs to the agent that will ' +
                 'be woken about it. Report back instead, and let the agent that asked you propose it.');
         }
-        const metric = source.metric(input.metric);
-        if (metric === undefined) {
-            return refusal('unknown-metric', `no metric "${input.metric}" is installed here. Call goal.metrics and name one of those; a goal ` +
-                'without a metric is a reminder.');
+        const resolved = await resolveMetric(input, ctx);
+        if (!resolved.ok)
+            return resolved;
+        const metric = resolved.metric;
+        let params = {};
+        if (metric.owner !== null) {
+            if (input.params !== undefined && Object.keys(input.params).length > 0) {
+                return refusal('invalid-params', `${metric.id} is a number the owner reports; it takes no parameters.`);
+            }
+        }
+        else {
+            if (input.baseline !== undefined) {
+                return refusal('baseline-measured', `${metric.id} is measured by its plugin, so the baseline is measured too; leave baseline out.`);
+            }
+            const checked = checkMetricParams(source.metric(metric.id), input.params);
+            if (!checked.ok)
+                return refusal('invalid-params', checked.message);
+            params = checked.params;
+        }
+        if (input.target.kind === 'frequency') {
+            /*
+             * A frequency goal counts values, and only the owner's metrics have
+             * values to count: a plugin's number is a level, read when buddi looks.
+             */
+            if (metric.owner === null) {
+                return refusal('frequency-needs-owner', `a frequency goal counts the times the owner tells buddi, and ${metric.id} is measured by a plugin. ` +
+                    'Use an owner metric ({"owner": {...}}) for something the owner does, or a level target for this one.');
+            }
+            if (input.baseline !== undefined) {
+                return refusal('baseline-frequency', 'a frequency goal starts with nothing counted; leave baseline out.');
+            }
+            const streaks = refuseStreaks(input.milestones ?? []);
+            if (streaks !== null)
+                return streaks;
         }
-        const params = checkMetricParams(metric, input.params);
-        if (!params.ok)
-            return refusal('invalid-params', params.message);
         const when = parseReminderWhen(input.deadline, ctx.timezone);
         if (!when.ok)
             return refusal('invalid-deadline', when.message);
@@ -316,26 +555,35 @@ export function createGoalManifest(source) {
             return refusal('deadline-too-far', `a goal can run at most ${MAX_GOAL_HORIZON_DAYS} days; that deadline is further out than anyone can ` +
                 'hold a plan to.');
         }
-        return null;
+        return { ok: true, metric, params };
     }
-    /** The envelope, from the arguments and one measurement. */
-    function envelopeOf(input, ctx, baseline) {
+    /** The envelope, from the arguments, the resolved metric and one measurement. */
+    function envelopeOf(input, ctx, metric, params, baseline) {
         const when = parseReminderWhen(input.deadline, ctx.timezone);
-        const metric = source.metric(input.metric);
-        const params = metric === undefined ? { ok: false } : checkMetricParams(metric, input.params);
         return {
             tool: 'goal.set',
             agentId: ctx.agentId ?? '',
             title: input.title.trim(),
-            metric: input.metric,
+            metric: metric.id,
             // What the schema *made of* the input — defaults applied, unknown keys
             // already refused — so the goal row and every later measurement agree.
-            params: params.ok ? params.params : (input.params ?? {}),
-            target: { kind: input.target.kind, value: input.target.value },
+            params,
+            target: input.target.kind === 'frequency'
+                ? { kind: 'frequency', count: input.target.count, per: input.target.per }
+                : { kind: input.target.kind, value: input.target.value },
             baseline,
             deadline: (when.ok ? when.at : new Date(0)).toISOString(),
             cadence: input.cadence,
             milestones: input.milestones ?? [],
+            ...(metric.owner === null
+                ? {}
+                : {
+                    owner: {
+                        metric: metric.owner.metric,
+                        isNew: metric.owner.isNew,
+                        baselineTold: input.baseline !== undefined,
+                    },
+                }),
         };
     }
     /** The baseline an approval already carries, when it carries one. */
@@ -351,23 +599,50 @@ export function createGoalManifest(source) {
             readingAsOf: baseline.readingAsOf ?? null,
         };
     }
+    /**
+     * The approved envelope's word on whether the owner metric was new.
+     *
+     * "New" is a fact about the moment the card was drawn: by the time the
+     * executor re-describes, another approval may have created the slug, and a
+     * card that said "a new metric" must not be voided for that — the definition
+     * already had to agree for the second goal to get this far.
+     */
+    function approvedIsNew(ctx, metric) {
+        const envelope = (ctx.approvedEffect?.envelope ?? null);
+        if (metric.owner === null || envelope?.owner === undefined)
+            return metric;
+        return { ...metric, owner: { ...metric.owner, isNew: envelope.owner.isNew === true } };
+    }
     const metrics = {
         name: 'goal.metrics',
         description: 'Every number this installation can actually measure, with what it means, which way is better and the ' +
-            'narrowing it takes. A goal watches one of these — name one from here when you propose a goal, and if ' +
-            'the list is empty then nothing installed here can be measured and a goal is the wrong tool.',
+            'narrowing it takes. A goal watches one of these — name one from here when you propose a goal. Source ' +
+            '"plugin" is measured by a plugin; source "owner" is a number the owner reports with goal.record. When ' +
+            'nothing here measures what the owner named, goal.set can create an owner metric.',
         tier: 'auto',
         input: z.object({}).strict(),
-        async execute() {
+        async execute(_input, ctx) {
+            await source.refresh(ctx.db);
             return {
-                metrics: source.metrics().map((metric) => ({
-                    id: metric.id,
-                    plugin: metric.plugin,
-                    description: metric.description,
-                    unit: metric.unit,
-                    direction: metric.direction,
-                    ...(metricParamsSchema(metric) === undefined ? {} : { params: metricParamsSchema(metric) }),
-                })),
+                metrics: source.metrics().map((metric) => isOwnerMetric(metric)
+                    ? {
+                        id: metric.id,
+                        source: OWNER_SOURCE,
+                        description: metric.description,
+                        label: metric.label,
+                        unit: metric.unit,
+                        ...(metric.unitLabel === null ? {} : { unitLabel: metric.unitLabel }),
+                        direction: metric.direction,
+                    }
+                    : {
+                        id: metric.id,
+                        source: 'plugin',
+                        plugin: metric.plugin,
+                        description: metric.description,
+                        unit: metric.unit,
+                        direction: metric.direction,
+                        ...(metricParamsSchema(metric) === undefined ? {} : { params: metricParamsSchema(metric) }),
+                    }),
             };
         },
     };
@@ -379,7 +654,8 @@ export function createGoalManifest(source) {
             'deadline gets close. The owner sees the whole shape before they say yes: where the number is today, ' +
             'where it has to get to, by when, what that is per week, and that it is you who will be speaking about ' +
             `it. At most ${MAX_OPEN_GOALS} open goals in an installation. Use it for something measurable that ` +
-            'runs for weeks; for one future nudge use reminder.set.',
+            'runs for weeks; for one future nudge use reminder.set. When no plugin measures the number (a weight, ' +
+            'a time), create an owner metric with {"owner": {...}} and pass the baseline the owner said.',
         tier: 'gated',
         input: setInput,
         /*
@@ -392,9 +668,11 @@ export function createGoalManifest(source) {
          * the owner is never shown a card for a goal that could not exist.
          */
         async describe(input, ctx) {
-            const no = refuseSet(input, ctx);
-            if (no !== null)
-                throw new Error(no.message);
+            await source.refresh(ctx.db);
+            const checked = await refuseSet(input, ctx);
+            if (!checked.ok)
+                throw new Error(checked.message);
+            const metric = approvedIsNew(ctx, checked.metric);
             /*
              * Measure **once**, on the first description. The executor re-describes
              * before it dispatches and compares envelope hashes, so a second
@@ -403,43 +681,57 @@ export function createGoalManifest(source) {
              * hopeless for an unread count, and `email.inbox_unread` is one of the
              * metrics this exists for. At re-description the approved envelope is on
              * the context, so the number the owner saw is the number that executes.
+             *
+             * A number the owner just said is the baseline as it is: there is
+             * nothing to measure, and it is the one sentence the goal came from.
              */
             const baseline = approvedBaseline(ctx) ??
-                (await (async () => {
-                    const measured = await measureMetricResult(source, input.metric, input.params ?? {}, ctx);
-                    if (!measured.ok) {
-                        /*
-                         * The card is never shown for a metric nobody can read. Approving
-                         * "from ? today to 47,400" is approving nothing, and the baseline
-                         * is the one number the whole goal is relative to.
-                         */
-                        throw new Error(`${input.metric} cannot be measured right now, so there is no baseline to set a goal against: ` +
-                            `${measured.note ?? 'no reason given'}. Fix that first — a goal needs a number to start from.`);
-                    }
-                    return {
-                        value: measured.reading.value,
-                        currency: measured.reading.currency ?? null,
-                        asOf: ctx.now().toISOString(),
-                        readingAsOf: measured.reading.asOf?.toISOString() ?? null,
-                    };
-                })());
-            const envelope = envelopeOf(input, ctx, baseline);
-            const direction = directionOf(input.metric);
-            const wrongWay = refuseDirection({ target: envelope.target, baseline: { value: baseline.value, asOf: new Date(baseline.asOf) } }, envelope.milestones, direction, unitOf(input.metric), baseline.currency);
+                // A frequency goal starts with nothing counted: there is no level to measure.
+                (input.target.kind === 'frequency'
+                    ? { value: 0, currency: null, asOf: ctx.now().toISOString(), readingAsOf: null }
+                    : input.baseline !== undefined && metric.owner !== null
+                        ? { value: input.baseline.value, currency: null, asOf: ctx.now().toISOString(), readingAsOf: null }
+                        : await (async () => {
+                            const measured = metric.owner !== null && metric.owner.isNew
+                                ? { ok: false, note: 'the owner has told buddi no value yet' }
+                                : await measureMetricResult(source, metric.id, metric.owner !== null ? { cadence: input.cadence } : checked.params, ctx);
+                            if (!measured.ok) {
+                                /*
+                                 * The card is never shown for a metric nobody can read.
+                                 * Approving "from ? today to 47,400" is approving nothing, and
+                                 * the baseline is the one number the whole goal is relative to.
+                                 */
+                                throw new Error(metric.owner !== null
+                                    ? `${metric.id} has no recent value, so there is no baseline to set a goal against. Ask the ` +
+                                        'owner where they are today and pass it as baseline: {"value": ...}.'
+                                    : `${metric.id} cannot be measured right now, so there is no baseline to set a goal against: ` +
+                                        `${measured.note ?? 'no reason given'}. Fix that first — a goal needs a number to start from.`);
+                            }
+                            return {
+                                value: measured.reading.value,
+                                currency: measured.reading.currency ?? null,
+                                asOf: ctx.now().toISOString(),
+                                readingAsOf: measured.reading.asOf?.toISOString() ?? null,
+                            };
+                        })());
+            const envelope = envelopeOf(input, ctx, metric, checked.params, baseline);
+            const wrongWay = envelope.target.kind === 'frequency' ? null : refuseDirection({ target: envelope.target, baseline: { value: baseline.value, asOf: new Date(baseline.asOf) } }, envelope.milestones, metric.direction, metric.unit, baseline.currency);
             if (wrongWay !== null)
                 throw new Error(wrongWay.message);
             return {
                 envelope,
-                preview: renderGoalSet(envelope, unitOf(input.metric), direction, ctx.timezone),
+                preview: renderGoalSet(envelope, metric.unit, metric.direction, ctx.timezone),
             };
         },
         async execute(input, ctx) {
             // Only `executeApproved` reaches this. The checks run again anyway: the
             // approval was recorded minutes or hours ago, and "a delegate may not"
             // is a fact about the run that is executing, not about the one that asked.
-            const no = refuseSet(input, ctx);
-            if (no !== null)
-                throw new Error(no.message);
+            await source.refresh(ctx.db);
+            const checked = await refuseSet(input, ctx);
+            if (!checked.ok)
+                throw new Error(checked.message);
+            const metric = approvedIsNew(ctx, checked.metric);
             /*
              * The baseline is the approval's: it is the number the owner saw, and a
              * goal measured against a different one is a different goal. Everything
@@ -451,7 +743,7 @@ export function createGoalManifest(source) {
             if (baseline === null) {
                 throw new Error('the effect no longer matches the approved preview; propose it again');
             }
-            const envelope = envelopeOf(input, ctx, baseline);
+            const envelope = envelopeOf(input, ctx, metric, checked.params, baseline);
             assertApprovedEffect(ctx, envelope);
             const created = await createGoal(ctx.db, {
                 title: envelope.title,
@@ -467,6 +759,26 @@ export function createGoalManifest(source) {
             });
             if (!created.ok)
                 return { ok: false, reason: created.reason, message: created.message };
+            /*
+             * The owner metric is created only now that the goal exists — a goal the
+             * budget refused leaves no definition behind — and a baseline the owner
+             * said is the metric's first value, so the next thing they tell buddi is
+             * measured against it.
+             */
+            if (envelope.owner !== undefined) {
+                const owned = await createOwnerMetric(ctx.db, envelope.owner.metric);
+                source.remember(owned);
+                if (envelope.owner.baselineTold) {
+                    await recordOwnerValue(ctx.db, {
+                        slug: owned.slug,
+                        value: envelope.baseline.value,
+                        at: new Date(envelope.baseline.asOf),
+                        note: 'baseline, said when the goal was set',
+                        source: valueSourceOf(ctx),
+                        conversationId: ctx.conversationId ?? null,
+                    });
+                }
+            }
             // The baseline is also the first check: a goal's history starts where
             // the owner was told it starts, not at the first sentinel tick.
             await recordCheck(ctx.db, {
@@ -475,12 +787,16 @@ export function createGoalManifest(source) {
                 asOf: envelope.baseline.readingAsOf === null ? null : new Date(envelope.baseline.readingAsOf),
                 value: envelope.baseline.value,
                 currency: envelope.baseline.currency,
-                note: 'baseline, measured when the goal was set',
-                paceNeeded: paceNeeded(created.goal, envelope.baseline.value, ctx.now()),
+                note: envelope.target.kind === 'frequency'
+                    ? 'set; nothing counted yet'
+                    : envelope.owner?.baselineTold === true
+                        ? 'baseline, said when the goal was set'
+                        : 'baseline, measured when the goal was set',
+                paceNeeded: envelope.target.kind === 'frequency' ? null : paceNeeded(created.goal, envelope.baseline.value, ctx.now()),
             });
             return {
                 ok: true,
-                goal: renderGoal(created.goal, unitOf(envelope.metric), ctx.timezone, unchecked(created.goal, ctx.now()), [], ctx.now()),
+                goal: renderGoal(created.goal, metric.unit, ctx.timezone, unchecked(created.goal, ctx.now()), [], ctx.now()),
             };
         },
     };
@@ -540,6 +856,18 @@ export function createGoalManifest(source) {
             }
         }
         const after = afterOf(input, goal, ctx);
+        /*
+         * A goal keeps its shape. A level goal's baseline is a number and a
+         * frequency goal's is nothing counted; turning one into the other would
+         * judge months of history against a baseline that never meant that.
+         */
+        if ((goal.target.kind === 'frequency') !== (after.target.kind === 'frequency')) {
+            return refusal('shape', goal.target.kind === 'frequency'
+                ? 'this is a frequency goal and stays one; a level target is a new goal.'
+                : 'this goal aims at a level and stays one; a frequency is a new goal on an owner metric.');
+        }
+        if (after.target.kind === 'frequency')
+            return refuseStreaks(after.milestones);
         // Same rule as `goal.set`: an update that puts the target on the wrong
         // side of the baseline would settle the goal `met` on the next tick.
         return refuseDirection({ target: after.target, baseline: goal.baseline }, after.milestones, directionOf(goal.metric), unitOf(goal.metric), goal.currency);
@@ -556,6 +884,7 @@ export function createGoalManifest(source) {
         // any action exists, and the owner is never asked about a change nobody
         // is allowed to make.
         async describe(input, ctx) {
+            await source.refresh(ctx.db);
             const mine = await holderOf(input.id, ctx);
             if (!mine.ok)
                 throw new Error(mine.message);
@@ -570,6 +899,7 @@ export function createGoalManifest(source) {
             };
         },
         async execute(input, ctx) {
+            await source.refresh(ctx.db);
             const mine = await holderOf(input.id, ctx);
             if (!mine.ok)
                 throw new Error(mine.message);
@@ -610,6 +940,7 @@ export function createGoalManifest(source) {
         tier: 'auto',
         input: closeInput,
         async execute(input, ctx) {
+            await source.refresh(ctx.db);
             const mine = await holderOf(input.id, ctx);
             if (!mine.ok)
                 return mine;
@@ -648,19 +979,63 @@ export function createGoalManifest(source) {
      */
     function renderGoal(goal, unit, timezone, standing, checks, 
     /** The run's clock. Never `new Date()`: `goal.status` is read under one. */
-    now) {
+    now, 
+    /** For a goal on an owner metric: its newest values, and a frequency goal's windows. */
+    owner = null) {
         const currency = goal.currency;
         const latest = standing.latest;
         const value = latest?.value ?? null;
         const projected = standing.projected;
         void now;
+        const ownerFields = owner === null
+            ? {}
+            : {
+                values: owner.values.slice(0, STATUS_VALUES).map((v) => ({
+                    asOf: v.asOf.toISOString(),
+                    value: v.value,
+                    valueFormatted: formatValue(v.value, unit, null),
+                    note: v.note,
+                    source: v.source,
+                })),
+            };
+        const frequency = owner?.frequency ?? null;
+        if (goal.target.kind === 'frequency' && frequency !== null) {
+            /*
+             * A frequency goal's numbers are windows, not a level: the value is the
+             * count so far in this window, the pace is what is left to do in it,
+             * and the verdict is the last window that closed.
+             */
+            const last = frequency.lastClosed;
+            const onTrackNow = last === null || last.state === 'partial' ? null : last.state === 'met';
+            return {
+                ...renderGoal({ ...goal }, unit, timezone, standing, checks, now),
+                ...ownerFields,
+                value: frequency.current?.count ?? null,
+                valueFormatted: frequencyNow(goal, frequency),
+                progress: null,
+                paceNeeded: frequency.toGo,
+                paceNeededInWords: frequency.toGo === null ? null : frequency.toGo === 0 ? 'done this ' + goal.target.per : `${frequency.toGo} more this ${goal.target.per}`,
+                projected: null,
+                onTrack: onTrackNow,
+                verdict: onTrackNow === null ? 'no-projection' : onTrackNow ? 'on-track' : 'off-track',
+                streak: frequency.streak,
+                windows: frequency.windows.slice(-STATUS_WINDOWS).map((w) => ({
+                    start: w.start,
+                    end: w.end,
+                    count: w.count,
+                    state: w.state,
+                })),
+            };
+        }
         return {
+            ...ownerFields,
             id: goal.id,
             title: goal.title,
             agentId: goal.agentId,
             metric: goal.metric,
             params: goal.params,
-            unit,
+            unit: baseUnit(unit),
+            unitLabel: unitLabelOf(unit),
             target: goal.target,
             targetValue: targetValue(goal),
             baseline: { value: goal.baseline.value, asOf: goal.baseline.asOf.toISOString() },
@@ -705,6 +1080,7 @@ export function createGoalManifest(source) {
         tier: 'auto',
         input: statusInput,
         async execute(input, ctx) {
+            await source.refresh(ctx.db);
             const goals = input.id === undefined
                 ? await listGoals(ctx.db, { agentId: ctx.agentId ?? '', limit: 50 })
                 : await (async () => {
@@ -735,7 +1111,13 @@ export function createGoalManifest(source) {
                  */
                 const printed = await recentChecks(ctx.db, goal.id, 4);
                 const standing = standingOf(goal, directionOf(goal.metric), await measuredChecks(ctx.db, goal.id, STANDING_CHECKS), ctx.now());
-                out.push(renderGoal(goal, unitOf(goal.metric), ctx.timezone, standing, printed, ctx.now()));
+                const ownerInfo = ownerSlugOf(goal.metric) !== null
+                    ? {
+                        values: await goalOwnerValues(ctx.db, goal),
+                        frequency: await frequencyOf(ctx.db, goal, ctx.now(), ctx.timezone),
+                    }
+                    : null;
+                out.push(renderGoal(goal, unitOf(goal.metric), ctx.timezone, standing, printed, ctx.now(), ownerInfo));
                 if (goals.length === 1) {
                     /*
                      * The chart is the goal's *history*, not its last four looks: a
@@ -743,12 +1125,147 @@ export function createGoalManifest(source) {
                      * milestone crossed in week two would have no event on it. Its own
                      * read, so the printed rows stay four.
                      */
-                    chart = chartOf(goal, unitOf(goal.metric), directionOf(goal.metric), await recentChecks(ctx.db, goal.id, CHART_CHECKS), ctx.timezone);
+                    chart = chartOf(goal, unitOf(goal.metric), directionOf(goal.metric), await recentChecks(ctx.db, goal.id, CHART_CHECKS), ctx.timezone, ownerInfo);
                 }
             }
             return chart === null ? { goals: out } : { goals: out, chart };
         },
     };
+    /**
+     * Where a goal stands, in one sentence: what `goal.record` answers with.
+     *
+     * Read off `standingOf` like every other surface, with the value just said
+     * stood in front of the measured checks — it is not a check yet, and the
+     * owner wants to know what it means now, not after the next tick.
+     */
+    function paceSentence(goal, standing, timezone) {
+        const unit = unitOf(goal.metric);
+        const direction = directionOf(goal.metric);
+        const value = standing.latest?.value ?? null;
+        const target = formatValue(targetValue(goal), unit, goal.currency);
+        const by = localDateString(goal.deadline, timezone);
+        const pct = standing.progress === null ? '' : `, ${Math.round(standing.progress * 100)}% of the way`;
+        const pace = standing.paceNeeded === null
+            ? 'the deadline has passed'
+            : `${formatPace(standing.paceNeeded, unit, direction, goal.currency)} from here reaches ${target} by ${by}`;
+        return `${goal.title}: ${formatValue(value, unit, goal.currency)} now${pct}; ${pace}.`;
+    }
+    const record = {
+        name: 'goal.record',
+        description: 'Write down a number the owner just told you for a metric they report ("285 this morning", "ran today" ' +
+            'is 1). Name the goal or the metric, not whose goal it is — any agent may record, so the owner can say it ' +
+            'to whoever is listening. Answers with where the goal stands now, in one sentence you can repeat. A value ' +
+            'far from the last one is refused with a sentence: ask the owner, then record again with confirmed: true.',
+        tier: 'auto',
+        input: recordInput,
+        async execute(input, ctx) {
+            await source.refresh(ctx.db);
+            if ((input.goal === undefined) === (input.metric === undefined)) {
+                return refusal('name-one', 'name the goal or the metric, exactly one of them');
+            }
+            /*
+             * Which series. A goal names its metric; a metric may be named as
+             * `owner.weight` or just `weight`. Either way it has to be one the owner
+             * reports: a plugin's number is measured, and typing over it would be a
+             * second, disagreeing history.
+             */
+            let goals = [];
+            let metricId;
+            if (input.goal !== undefined) {
+                const goal = await getGoal(ctx.db, input.goal).catch(() => null);
+                if (goal === null)
+                    return refusal('not-found', `no goal ${input.goal}`);
+                metricId = goal.metric;
+                goals = [goal];
+            }
+            else {
+                const raw = input.metric.trim();
+                metricId = raw.includes('.') ? raw : ownerMetricId(raw);
+            }
+            const metric = source.metric(metricId);
+            if (!isOwnerMetric(metric)) {
+                return refusal('not-owner-metric', metric === undefined
+                    ? `no metric "${metricId}" is kept here. goal.metrics lists the ones the owner reports (source "owner").`
+                    : `${metricId} is measured by ${metric.plugin}; there is nothing to record by hand.`);
+            }
+            const slug = ownerSlugOf(metric.id);
+            if (input.goal === undefined) {
+                goals = (await listGoals(ctx.db, { openOnly: true, limit: MAX_OPEN_GOALS })).filter((goal) => goal.metric === metric.id);
+            }
+            const now = ctx.now();
+            let asOf = now;
+            if (input.asOf !== undefined) {
+                const when = parseReminderWhen(input.asOf, ctx.timezone);
+                if (!when.ok)
+                    return refusal('invalid-as-of', when.message);
+                asOf = when.at;
+                // "This morning" written as today's date lands at 09:00; before nine
+                // that is a few hours ahead of the clock, and it still means today.
+                if (asOf.getTime() > now.getTime()) {
+                    if (localDateString(asOf, ctx.timezone) !== localDateString(now, ctx.timezone)) {
+                        return refusal('as-of-future', `${input.asOf} has not happened yet; a value is true of now or of the past`);
+                    }
+                    asOf = now;
+                }
+            }
+            const unit = unitOf(metric.id);
+            if (input.confirmed !== true) {
+                const last = await latestOwnerValue(ctx.db, slug);
+                const outside = refuseOutsideBand(last?.value ?? null, input.value, (n) => formatValue(n, unit, null));
+                if (outside !== null)
+                    return refusal('confirm', outside);
+            }
+            const conversationId = ctx.conversationId !== undefined && UUID.test(ctx.conversationId) ? ctx.conversationId : null;
+            const saved = await recordOwnerValue(ctx.db, {
+                slug,
+                value: input.value,
+                at: now,
+                asOf,
+                note: input.note ?? null,
+                source: valueSourceOf(ctx),
+                conversationId,
+            });
+            const lines = [];
+            for (const goal of goals) {
+                if (goal.state !== 'open')
+                    continue;
+                const frequency = await frequencyOf(ctx.db, goal, now, ctx.timezone);
+                if (frequency !== null) {
+                    // The value is saved, so the windows already count it.
+                    lines.push(`${goal.title}: ${frequencyNow(goal, frequency)}.`);
+                    continue;
+                }
+                const pending = {
+                    id: '',
+                    goalId: goal.id,
+                    at: now,
+                    asOf,
+                    value: input.value,
+                    currency: null,
+                    note: null,
+                    onTrack: null,
+                    paceNeeded: null,
+                    projected: null,
+                };
+                const standing = standingOf(goal, directionOf(goal.metric), [pending, ...(await measuredChecks(ctx.db, goal.id, STANDING_CHECKS))], now);
+                lines.push(paceSentence(goal, standing, ctx.timezone));
+            }
+            return {
+                ok: true,
+                recorded: {
+                    metric: metric.id,
+                    value: saved.value,
+                    valueFormatted: formatValue(saved.value, unit, null),
+                    asOf: saved.asOf.toISOString(),
+                    source: saved.source,
+                },
+                // One sentence per open goal on this metric; usually exactly one.
+                pace: lines.length === 0
+                    ? `Recorded ${formatValue(saved.value, unit, null)}; no open goal watches ${metric.id}.`
+                    : lines.join(' '),
+            };
+        },
+    };
     const list = {
         name: 'goal.list',
         description: 'Every open goal in this installation, whoever holds it, one line each. Reading is open to any agent — ' +
@@ -757,6 +1274,7 @@ export function createGoalManifest(source) {
         tier: 'auto',
         input: z.object({}).strict(),
         async execute(_input, ctx) {
+            await source.refresh(ctx.db);
             const goals = await listGoals(ctx.db, { openOnly: true, limit: MAX_OPEN_GOALS });
             const out = [];
             for (const goal of goals) {
@@ -780,7 +1298,7 @@ export function createGoalManifest(source) {
         // core concept and this manifest only exposes it to a model.
         schema: 'core',
         migrationsDir: '',
-        tools: [metrics, set, update, close, status, list, createGoalOwnerClose()],
+        tools: [metrics, set, update, close, status, list, record, createGoalOwnerClose()],
         sentinels: [createGoalsSentinel(source)],
         // Where a goal shows (§7): a block on Home, a rail page, and one way of
         // drawing `goal.status` on the canvas. All three are in `goals-page.ts`;
@@ -794,12 +1312,37 @@ export function createGoalManifest(source) {
 /* ------------------------------------------------------------------ *
  * The watcher
  * ------------------------------------------------------------------ */
+/**
+ * How long an off-track goal stays quiet after it woke its holder: one
+ * cadence. Whole days, not the four-hour-early "due" margin — the margin keeps
+ * checks from drifting; this keeps the same news from arriving twice a week.
+ */
+export function offTrackCooldownMs(cadence) {
+    return (cadence === 'daily' ? 1 : 7) * 24 * 60 * 60_000;
+}
 /** Is this goal's cadence due again? See `DAILY_DUE_MS` for the margin. */
 export function cadenceDue(cadence, lastAt, now) {
     if (lastAt === null)
         return true;
     return now.getTime() - lastAt.getTime() >= (cadence === 'daily' ? DAILY_DUE_MS : WEEKLY_DUE_MS);
 }
+/**
+ * Which cadence window an owner metric has gone quiet into, or null.
+ *
+ * Windows are counted from `since` — the newest value, or when the goal was
+ * set — one cadence at a time: a weekly goal last told on a Monday morning is
+ * stale from the next Monday morning, and again from the one after. The label
+ * is the owner's day the window began, which is what the finding key and the
+ * notification's dedupe key carry, so each window is said at most once.
+ */
+export function staleWindow(since, now, cadence, timezone) {
+    const length = cadenceMs(cadence);
+    const elapsed = now.getTime() - since.getTime();
+    if (elapsed < length)
+        return null;
+    const start = new Date(since.getTime() + Math.floor(elapsed / length) * length);
+    return localDateString(start, timezone);
+}
 /**
  * The `core.goals` watcher.
  *
@@ -813,7 +1356,123 @@ export function cadenceDue(cadence, lastAt, now) {
  * and a settled goal is no longer open, so every key under it stops being
  * returned on the next tick and resolves. The wake it raised has already gone.
  */
-export function createGoalsSentinel(source) {
+export function createGoalsSentinel(base) {
+    const source = asOwnerSource(base);
+    /**
+     * One tick of a frequency goal: its windows, a check on its cadence, and
+     * the three things worth saying — a window that closed short, a streak
+     * milestone, the deadline.
+     *
+     * Each is keyed so it is said once. The short window's key carries the
+     * window, and it is returned only while that window is the newest closed
+     * one; a streak milestone is returned while the window that reached it is
+     * the newest closed one, and never again once raised for another. There is
+     * no staleness line: a week with nothing said is a short week, not silence.
+     */
+    async function frequencyTick(goal, ctx, now) {
+        if (goal.target.kind !== 'frequency')
+            return [];
+        const { count, per } = goal.target;
+        const unit = valueUnitOf(source, goal.metric);
+        const standing = (await frequencyOf(ctx.db, goal, now, ctx.timezone));
+        const lastClosed = standing.lastClosed;
+        const verdictOf = (w) => w === null || w.state === 'partial' ? null : w.state === 'met';
+        let checks = await recentChecks(ctx.db, goal.id, 4);
+        const lastAt = checks[0]?.at ?? null;
+        const pastDeadline = now.getTime() >= goal.deadline.getTime();
+        const deadlineUnmeasured = pastDeadline && (lastAt === null || lastAt.getTime() < goal.deadline.getTime());
+        if (deadlineUnmeasured || cadenceDue(goal.cadence, lastAt, now)) {
+            // The record of the tally as it stood: the count this window, the
+            // verdict of the last closed one, what is left to do.
+            await recordCheck(ctx.db, {
+                goalId: goal.id,
+                at: now,
+                value: standing.current?.count ?? lastClosed?.count ?? 0,
+                note: frequencyNow(goal, standing),
+                onTrack: verdictOf(lastClosed),
+                paceNeeded: standing.toGo,
+            });
+            checks = await recentChecks(ctx.db, goal.id, 4);
+        }
+        const recent = standing.windows.slice(-6);
+        const detail = (lead) => [
+            lead,
+            '',
+            goalLine(goal, unit, checks[0] ?? null, ctx.timezone),
+            '',
+            `The last ${recent.length} ${per}s:`,
+            ...recent.map((w) => `  ${per} of ${w.start}: ${w.count} of ${count} · ${w.state}`),
+            '',
+            GOAL_WAKE_INSTRUCTION,
+        ].join('\n');
+        const data = {
+            goalId: goal.id,
+            metric: goal.metric,
+            target: { count, per },
+            deadline: goal.deadline.toISOString(),
+            streak: standing.streak,
+            windows: recent.map((w) => ({ start: w.start, count: w.count, state: w.state })),
+        };
+        const base = { agentId: goal.agentId, data };
+        const out = [];
+        // The deadline: settled by the windows, met when more met than fell short.
+        if (pastDeadline) {
+            const verdict = frequencySettles(standing);
+            await settleGoal(ctx.db, goal.id, verdict, verdict === 'met' ? 'more windows met the count than fell short' : 'more windows fell short than met the count', now);
+            out.push(verdict === 'met'
+                ? {
+                    ...base,
+                    key: goalKey(goal.id, 'target-reached'),
+                    severity: 'info',
+                    wake: true,
+                    title: `Goal reached: ${goal.title}`,
+                    detail: detail(`${standing.met} ${per}s met the count and ${standing.short} fell short.`),
+                }
+                : {
+                    ...base,
+                    key: goalKey(goal.id, 'deadline-passed'),
+                    severity: 'urgent',
+                    title: `Goal deadline passed: ${goal.title}`,
+                    detail: detail(`The deadline was ${localDateString(goal.deadline, ctx.timezone)}: ${standing.met} ${per}s met ` +
+                        `the count and ${standing.short} fell short.`),
+                });
+            return out;
+        }
+        // Drift: the newest closed window fell short. Said once, for that window.
+        if (lastClosed?.state === 'short') {
+            out.push({
+                ...base,
+                key: goalKey(goal.id, `short.${lastClosed.start}`),
+                severity: 'info',
+                wake: true,
+                title: `Short last ${per}: ${goal.title}`,
+                detail: detail(`${lastClosed.count} of ${count} in the ${per} of ${lastClosed.start}.`),
+            });
+        }
+        // Streaks: each milestone once, ever, for the window that reached it.
+        if (lastClosed?.state === 'met' && goal.milestones.length > 0) {
+            const { rows } = await ctx.db.query(`select key, data->>'window' as window from core.sentinel_findings
+          where sentinel_id = $1 and key like $2`, [GOALS_SENTINEL_ID, `goal.${goal.id}.milestone.%`]);
+            const raisedFor = new Map(rows.map((r) => [r.key, r.window]));
+            for (const milestone of goal.milestones) {
+                if (standing.streak < milestone)
+                    continue;
+                const key = goalKey(goal.id, `milestone.${milestone}`);
+                if (raisedFor.has(key) && raisedFor.get(key) !== lastClosed.start)
+                    continue;
+                out.push({
+                    ...base,
+                    data: { ...data, window: lastClosed.start },
+                    key,
+                    severity: 'info',
+                    wake: true,
+                    title: `Milestone on ${goal.title}`,
+                    detail: detail(`${milestone} ${per}s in a row at ${frequencyWords(goal.target)}.`),
+                });
+            }
+        }
+        return out;
+    }
     return {
         id: GOALS_SENTINEL_ID,
         description: 'Measures every open goal on its cadence and says when one is off track, past a milestone, out of time or done.',
@@ -821,11 +1480,17 @@ export function createGoalsSentinel(source) {
         async run(ctx) {
             const now = ctx.now();
             const findings = [];
+            await source.refresh(ctx.db);
             const goals = await listGoals(ctx.db, { openOnly: true, limit: MAX_OPEN_GOALS });
             for (const goal of goals) {
                 const metric = source.metric(goal.metric);
-                const unit = metric?.unit ?? 'number';
+                const unit = valueUnitOf(source, goal.metric);
                 const direction = metric?.direction ?? 'down';
+                const owned = isOwnerMetric(metric);
+                if (goal.target.kind === 'frequency') {
+                    findings.push(...(await frequencyTick(goal, ctx, now)));
+                    continue;
+                }
                 const currency = goal.currency;
                 /*
                  * What was true *before* this tick's check, which is what "newly
@@ -845,44 +1510,62 @@ export function createGoalsSentinel(source) {
                 const lastAt = checks[0]?.at ?? null;
                 const deadlineUnmeasured = pastDeadline && (lastAt === null || lastAt.getTime() < goal.deadline.getTime());
                 if (deadlineUnmeasured || cadenceDue(goal.cadence, lastAt, now)) {
-                    const reading = await measureMetricResult(source, goal.metric, goal.params, goalToolContext(goal, ctx));
+                    // An owner metric is read against *this goal's* cadence: "older than
+                    // two cadences" is two weeks for a weekly goal, two days for a daily one.
+                    const reading = await measureMetricResult(source, goal.metric, owned ? { ...goal.params, cadence: goal.cadence } : goal.params, goalToolContext(goal, ctx));
                     const value = reading.ok ? reading.reading.value : null;
                     /*
-                     * The arithmetic of the row about to be written, over the same
-                     * window every other surface reads — with this tick's number stood
-                     * in front of it, because it is not a row yet. `standingOf` is what
-                     * the page and `goal.status` call afterwards, so the number stored
-                     * here is the number they will read back.
+                     * An owner metric is only news when the owner said something new.
+                     * Re-recording last week's number under this week's date would draw
+                     * a flat line the owner never reported and bend the projection
+                     * toward it, so a cadence with no new value records nothing — the
+                     * staleness finding below is what says so. The deadline still gets
+                     * its row, so the verdict is about a number taken at or after it.
                      */
-                    const before = await measuredChecks(ctx.db, goal.id, STANDING_CHECKS);
-                    const pending = {
-                        id: '',
-                        goalId: goal.id,
-                        at: now,
-                        asOf: null,
-                        value,
-                        currency: null,
-                        note: null,
-                        onTrack: null,
-                        paceNeeded: null,
-                        projected: null,
-                    };
-                    const prospective = standingOf(goal, direction, [pending, ...before], now);
-                    await recordCheck(ctx.db, {
-                        goalId: goal.id,
-                        at: now,
-                        asOf: reading.ok ? (reading.reading.asOf ?? null) : null,
-                        value,
-                        currency: reading.ok ? (reading.reading.currency ?? null) : null,
-                        // The reason it could not be measured is the check's note, so
-                        // "the plugin is gone" and "the bank has not synced" stay
-                        // different facts a week later.
-                        note: reading.ok ? (reading.reading.note ?? null) : (reading.note ?? null),
-                        onTrack: prospective.onTrack,
-                        paceNeeded: value === null ? null : prospective.paceNeeded,
-                        projected: prospective.projected,
-                    });
-                    checks = await recentChecks(ctx.db, goal.id, 4);
+                    const lastSeen = checks[0] === undefined ? null : (checks[0].asOf ?? checks[0].at);
+                    const nothingNew = owned &&
+                        !deadlineUnmeasured &&
+                        reading.ok &&
+                        lastSeen !== null &&
+                        (reading.reading.asOf?.getTime() ?? 0) <= lastSeen.getTime();
+                    if (!nothingNew) {
+                        /*
+                         * The arithmetic of the row about to be written, over the same
+                         * window every other surface reads — with this tick's number stood
+                         * in front of it, because it is not a row yet. `standingOf` is what
+                         * the page and `goal.status` call afterwards, so the number stored
+                         * here is the number they will read back.
+                         */
+                        const before = await measuredChecks(ctx.db, goal.id, STANDING_CHECKS);
+                        const pending = {
+                            id: '',
+                            goalId: goal.id,
+                            at: now,
+                            asOf: null,
+                            value,
+                            currency: null,
+                            note: null,
+                            onTrack: null,
+                            paceNeeded: null,
+                            projected: null,
+                        };
+                        const prospective = standingOf(goal, direction, [pending, ...before], now);
+                        await recordCheck(ctx.db, {
+                            goalId: goal.id,
+                            at: now,
+                            asOf: reading.ok ? (reading.reading.asOf ?? null) : null,
+                            value,
+                            currency: reading.ok ? (reading.reading.currency ?? null) : null,
+                            // The reason it could not be measured is the check's note, so
+                            // "the plugin is gone" and "the bank has not synced" stay
+                            // different facts a week later.
+                            note: reading.ok ? (reading.reading.note ?? null) : (reading.note ?? null),
+                            onTrack: prospective.onTrack,
+                            paceNeeded: value === null ? null : prospective.paceNeeded,
+                            projected: prospective.projected,
+                        });
+                        checks = await recentChecks(ctx.db, goal.id, 4);
+                    }
                 }
                 /*
                  * Every verdict below is read off *measured* checks, over the same
@@ -993,6 +1676,10 @@ export function createGoalsSentinel(source) {
                         ...base,
                         key: goalKey(goal.id, 'off-track'),
                         severity: 'urgent',
+                        // Bound to the goal's cadence: a weekly goal off track wakes its
+                        // holder at most once a week for the same drift, a daily one once
+                        // a day. The first time still wakes at once.
+                        cooldownMs: offTrackCooldownMs(goal.cadence),
                         title: `Off track: ${goal.title}`,
                         detail: detail(`Two checks running, the pace of the last four lands at ` +
                             `${formatValue(newest.projected, unit, currency)} by ` +
@@ -1018,6 +1705,37 @@ export function createGoalsSentinel(source) {
                  *    in a row, and fire on day four of an outage saying a number that
                  *    existed yesterday has been missing for months.
                  */
+                if (owned) {
+                    /*
+                     * 6'. For a number the owner reports, silence is not an outage: it is
+                     *     a week nobody said anything. Counted from the newest value (or
+                     *     from when the goal was set, if that is later), once per cadence
+                     *     that passes: the key and the notification's dedupe key carry
+                     *     the window, so it is said at most once in it, and the line
+                     *     waits for the end of the day — never `now`. "Not measurable"
+                     *     is not raised as well; it would be the same silence twice.
+                     */
+                    const slug = ownerSlugOf(goal.metric);
+                    const newest = await latestOwnerValue(ctx.db, slug);
+                    const since = new Date(Math.max(newest?.asOf.getTime() ?? 0, goal.baseline.asOf.getTime()));
+                    const window = staleWindow(since, now, goal.cadence, ctx.timezone);
+                    if (window !== null) {
+                        const label = isOwnerMetric(metric) ? metric.label.toLowerCase() : goal.metric;
+                        const period = goal.cadence === 'daily' ? 'today' : 'this week';
+                        findings.push({
+                            ...base,
+                            key: goalKey(goal.id, `stale.${window}`),
+                            severity: 'info',
+                            wake: true,
+                            notify: { urgency: 'today', dedupeKey: `goal:${goal.id}:stale:${window}` },
+                            title: `Not told ${period}: ${goal.title}`,
+                            detail: detail(`The owner has not told buddi their ${label} since ${localDateString(since, ctx.timezone)}. ` +
+                                `Say one line and nothing more, like "You have not told me your ${label} ${period}." ` +
+                                'When they answer, record it with goal.record.'),
+                        });
+                    }
+                    continue;
+                }
                 const lastMeasuredAt = latest?.at ?? goal.baseline.asOf;
                 if (now.getTime() - lastMeasuredAt.getTime() >= NOT_MEASURABLE_MS) {
                     findings.push({