feat(ai): forslag, man siger ja til — indbakken og noternes opgaver

To steder, hvor arbejdet ligger og venter på at blive skrevet færdigt.

Indbakken er der, hvor ting lander, når man ikke havde tid til at skrive
dem ordentligt — og derfor også der, hvor de bliver liggende. At åbne
hver enkelt og sætte projekt, dato og prioritet er ti klik pr. linje. Nu
er det ét spørgsmål og et ja pr. linje.

Og et referat er fuldt af sætninger, der ligner opgaver, og af tre, der
er det. Modellen bliver bedt om kun at tage dem, nogen har forpligtet sig
på, og om at citere de ord, den tog dem fra — så et forkert punkt kan
gennemskues frem for bare at være forkert.

Modellen skriver ikke noget. Den foreslår en *linje* i quick-add-syntaks,
og forslaget bliver til noget, når nogen siger ja. Det er ikke
forsigtighed for forsigtighedens skyld: en model, der retter i folks
opgaver direkte, skal have ret hver gang for at være til gavn, hvor en,
der foreslår, skal have ret tit nok til at spare et par tastetryk.

Linjen er quick-add-syntaks frem for et felt pr. egenskab, fordi parseren
findes. Der er én fortolkning af "i morgen" i dette program, og forslaget
går gennem den samme som alt andet — også når linjen er blevet rettet i
hånden, inden den blev accepteret. Og et forslag, skrevet i det sprog man
selv skriver i, kan læses og rettes af den, det bliver stillet til.

Modellen får listen over de projekter, der findes, og må ikke nævne
andre. Et `#Nyt projekt`, den fandt på, ville lave et projekt ved et
uheld, første gang nogen sagde ja — og et gæt må ikke kunne flytte en
opgave hen, hvor ejeren ikke leder efter den. Testet.

Forslagene til indbakken bærer et nummer tilbage til den opgave, de
handler om. Rækkefølgen alene ville også kunne bruges og gør det som
reserve, men en model, der springer en opgave over, ville så flytte alle
de følgende forslag én plads — og "sæt en dato på den her" ville lande på
en anden.

Noten bliver ikke rørt, når der laves opgaver ud af den. Det er
fristende at skrive linket ind i den, så de to peger på hinanden, men en
tekst, et program skriver i uden at blive bedt om det, er en tekst, man
holder op med at stole på. Opgaven bærer i stedet, hvor den kom fra.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

docs/openapi.yaml

@@ -2718,6 +2718,25 @@ paths:
       responses:
         "200": { $ref: "#/components/responses/MailAddress" }
 
+  /api/v1/hook-url:
+    get:
+      tags: [integrations]
+      summary: Your personal address for pushing a task in from somewhere else.
+      description: >
+        Minted on first ask. Its own token rather than the mail one: the two are
+        the same kind of secret, but they leak separately — a URL that has been
+        sitting in a shortcut on a lost phone has to be replaceable without
+        changing the address other people have in their address books.
+      responses:
+        "200": { $ref: "#/components/responses/HookURL" }
+
+  /api/v1/hook-url/rotate:
+    post:
+      tags: [integrations]
+      summary: Issue a new push address, retiring the old one at once.
+      responses:
+        "200": { $ref: "#/components/responses/HookURL" }
+
   /api/v1/notifications:
     get:
       tags: [integrations]
@@ -3431,6 +3450,124 @@ paths:
           $ref: "#/components/responses/Conflict"
         "502": { $ref: "#/components/responses/Upstream" }
 
+  /api/v1/ai/inbox/tidy:
+    post:
+      tags: [integrations]
+      summary: Suggest how the loose tasks in the inbox could have been written.
+      description: |
+        Suggests, never writes. Each suggestion is the line the person would have
+        typed — quick-add syntax, the same one parser as everywhere else — so it
+        can be read and edited by whoever it is put to, rather than being a set of
+        fields a model filled in that you take or leave.
+
+        The model is given the projects that exist and may name no other: a
+        `#Project` it invented would create one by accident the first time
+        somebody said yes.
+      responses:
+        "200":
+          description: The suggestions, one per task, and none for a task already filed well.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  suggestions:
+                    type: array
+                    items: { $ref: "#/components/schemas/AISuggestion" }
+        "409": { $ref: "#/components/responses/Conflict" }
+        "502": { $ref: "#/components/responses/Upstream" }
+
+  /api/v1/ai/inbox/tidy/apply:
+    post:
+      tags: [integrations]
+      summary: Write one accepted suggestion into the task it is about.
+      description: |
+        The line is parsed here rather than in the browser, so "tomorrow" means
+        what it means everywhere else — and a suggestion edited by hand before it
+        was accepted is read exactly like one that was not.
+
+        Only what the line actually says is applied. A missing date means "the
+        line said nothing about a date", never "clear the one that is there". A
+        project the model invented moves nothing.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [task_id, line]
+              properties:
+                task_id: { type: string }
+                line: { type: string }
+      responses:
+        "200":
+          description: The task as it now stands.
+          content:
+            application/json:
+              schema: { $ref: "#/components/schemas/Task" }
+        "404": { $ref: "#/components/responses/NotFound" }
+        "422": { $ref: "#/components/responses/Validation" }
+
+  /api/v1/ai/notes/{noteID}/actions:
+    parameters:
+      - { name: noteID, in: path, required: true, schema: { type: string } }
+    post:
+      tags: [integrations]
+      summary: Pull what somebody committed to out of a note.
+      description: |
+        Only things somebody committed to or was asked to do — a heading is not a
+        task, a topic discussed is not a task. An empty array is a useful answer
+        and a made-up list is not.
+
+        Each suggestion quotes the words it came from, so a wrong one can be seen
+        through rather than merely being wrong.
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  suggestions:
+                    type: array
+                    items: { $ref: "#/components/schemas/AISuggestion" }
+        "404": { $ref: "#/components/responses/NotFound" }
+        "409": { $ref: "#/components/responses/Conflict" }
+        "502": { $ref: "#/components/responses/Upstream" }
+
+  /api/v1/ai/notes/{noteID}/actions/apply:
+    parameters:
+      - { name: noteID, in: path, required: true, schema: { type: string } }
+    post:
+      tags: [integrations]
+      summary: Create one accepted task from a note.
+      description: |
+        The note is not touched. Writing the link back into it would make the two
+        point at each other, and a text a program edits without being asked is a
+        text people stop trusting — so the task carries where it came from, as a
+        `[[note title]]` in its description, and the note is left alone.
+
+        The note's own project is the default; a `#Project` in the line wins,
+        because typing it is a choice and inheriting is a circumstance.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [line]
+              properties:
+                line: { type: string }
+      responses:
+        "201":
+          description: Created
+          content:
+            application/json:
+              schema: { $ref: "#/components/schemas/Task" }
+        "404": { $ref: "#/components/responses/NotFound" }
+        "422": { $ref: "#/components/responses/Validation" }
+
   /api/v1/mcp:
     post:
       tags: [integrations]
@@ -3752,6 +3889,69 @@ paths:
                   task_id: { type: string }
         "404": { description: "No such address. Identical to a malformed one, deliberately." }
 
+  /inbound/hook/{token}:
+    post:
+      tags: [integrations]
+      summary: Push a task into somebody's inbox from another program.
+      description: |
+        The token in the path is the whole credential — the caller is a shortcut on
+        a phone or a script, and neither can sign in. A token here can do one
+        thing: create a task in that person's inbox. An API token can do everything,
+        which is why this is not one.
+
+        The body is read three ways, because those are the three you meet: JSON from
+        a service, a form field from a webhook form, and plain text from a shortcut
+        that just sends what was selected. The first line becomes the task and the
+        rest sits underneath it, and the line goes through the quick-add parser — so
+        "Ring til Anders i morgen p1 #Firma" means here what it means in the box at
+        the top of the app.
+
+        POST only. A GET would be easier to call, and that is exactly the problem:
+        a browser prefetch, a link check in a chat, and a revisited history entry
+        would all create tasks nobody asked for.
+      security: []
+      parameters:
+        - name: token
+          in: path
+          required: true
+          schema: { type: string }
+      requestBody:
+        required: true
+        content:
+          text/plain:
+            schema:
+              type: string
+              description: First line the task, the rest its description.
+          application/json:
+            schema:
+              type: object
+              properties:
+                text: { type: string }
+                title: { description: Same as text. }
+                content: { description: Same as text. }
+                note: { type: string }
+                body: { description: Same as note. }
+                description: { description: Same as note. }
+          application/x-www-form-urlencoded:
+            schema:
+              type: object
+              properties:
+                text: { type: string }
+                note: { type: string }
+      responses:
+        "201":
+          description: Created
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  task_id: { type: string }
+                  content: { type: string }
+        "404": { description: "No such address. Identical to a malformed one, deliberately." }
+        "422": { $ref: "#/components/responses/Validation" }
+        "429": { description: Too many pushes; the address is rate limited. }
+
   /oauth/gmail/callback:
     get:
       tags: [integrations]
@@ -4018,6 +4218,15 @@ components:
                 type: array
                 items: { type: string }
 
+    HookURL:
+      description: The address another program pushes to.
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              url: { type: string }
+
   schemas:
     Calendar:
       type: object
@@ -4142,6 +4351,21 @@ components:
         note_id: { type: string }
         title: { type: string }
 
+    AISuggestion:
+      type: object
+      description: >
+        One proposed line, in quick-add syntax, plus one sentence on why it looks
+        like that. Nothing has happened yet — a suggestion becomes something when
+        somebody says yes to it.
+      properties:
+        task_id:
+          type: string
+          description: >
+            The task the suggestion is about, when it is about one that already
+            exists. Absent when the suggestion is a new task.
+        line: { type: string, example: "Ring til Anders i morgen p1 #Firma" }
+        why: { type: string }
+
     NoteInvite:
       type: object
       description: >

internal/ai/ai.go

@@ -395,6 +395,132 @@ back, do not congratulate, and do not offer productivity advice.`, language)
 	return c.Complete(ctx, system, []Message{{Role: "user", Content: prompt}})
 }
 
+// Suggestion er én foreslået opgave, skrevet som en linje, man selv kunne have
+// tastet.
+//
+// `line` er quick-add-syntaks — "Ring til Anders i morgen p1 #Firma" — og ikke et
+// felt pr. egenskab. To grunde, og den anden er den vigtige. Parseren findes
+// allerede og er den samme, uanset hvor teksten kom fra, så der er ingen anden
+// fortolkning at holde i takt med den. Og et forslag, der er skrevet i det sprog,
+// man selv skriver i, kan læses og rettes af den, det bliver stillet til — hvor
+// et sæt felter, en model har udfyldt, er noget, man skal tage eller lade være.
+//
+// `why` er én sætning om, hvorfor den ser sådan ud. Den står ved siden af
+// forslaget, så et forkert gæt kan gennemskues frem for bare at være forkert.
+type Suggestion struct {
+	Line string `json:"line"`
+	Why  string `json:"why,omitempty"`
+}
+
+// TidyInbox foreslår, hvordan løse opgaver i indbakken kunne skrives færdig.
+//
+// Modellen får de projekter, der findes, og må kun bruge dem: et `#Nyt Projekt`,
+// den fandt på, ville lave et projekt ved et uheld, første gang nogen sagde ja.
+func (c *Client) TidyInbox(ctx context.Context, tasks, projects []string, today, locale string) ([]Suggestion, error) {
+	language := languageOf(locale)
+
+	known := "none"
+	if len(projects) > 0 {
+		known = "#" + strings.Join(projects, ", #")
+	}
+
+	system := fmt.Sprintf(`You tidy up a task inbox.
+
+For each task you are given, write the line the person would have typed if they
+had filed it properly. Keep their own words for what the task is — you are filing
+it, not rewriting it.
+
+The line may carry, in this syntax and no other:
+  #Project   one of these existing projects, and never one that is not: %s
+  p1..p4     priority, where p1 is most urgent
+  a date in plain %s, such as "i morgen", "on friday", "15/3"
+
+Leave out anything the task does not tell you. A guessed deadline is worse than
+none: the person can add one, but they cannot see a wrong one you invented.
+Today is %s.
+
+Reply with a JSON array and nothing else — no prose, no code fence. Each element
+is {"line": "...", "why": "..."} where why is at most one short sentence in %s
+saying what you read out of the task. Give one element per task, in the order you
+were given them, and leave a task out entirely if it is already filed well.`,
+		known, language, today, language)
+
+	prompt := "Tasks:\n" + strings.Join(tasks, "\n")
+	return c.suggestions(ctx, system, prompt)
+}
+
+// ActionsInNote trækker det, nogen har lovet, ud af en note.
+//
+// Beskrivelsen er stram med vilje. En model, der får lov at "finde opgaver" i en
+// tekst, finder også emner, overskrifter og gode idéer — og så er resultatet en
+// liste, man skal luge i, hvilket er dyrere end at skrive de tre punkter selv.
+func (c *Client) ActionsInNote(ctx context.Context, note string, projects []string, today, locale string) ([]Suggestion, error) {
+	language := languageOf(locale)
+
+	known := "none"
+	if len(projects) > 0 {
+		known = "#" + strings.Join(projects, ", #")
+	}
+
+	system := fmt.Sprintf(`You read a note and pull out what somebody has to do.
+
+Only things somebody committed to or was asked to do. A heading is not a task, a
+topic that was discussed is not a task, and an idea nobody agreed to is not a
+task. If the note contains none, reply with an empty array — that is a useful
+answer and a made-up list is not.
+
+Write each one as the line the person would have typed, in %s, in this syntax and
+no other:
+  #Project   one of these existing projects, and never one that is not: %s
+  p1..p4     priority, where p1 is most urgent
+  a date in plain %s, only when the note actually gives one
+
+Today is %s.
+
+Reply with a JSON array and nothing else — no prose, no code fence. Each element
+is {"line": "...", "why": "..."} where why quotes the few words in the note that
+the task came from, so it can be checked.`, language, known, language, today)
+
+	return c.suggestions(ctx, system, "Note:\n"+note)
+}
+
+// suggestions er den fælles halvdel: spørg, læs svaret som JSON, og smid det væk,
+// der ikke er en linje.
+//
+// Et tomt svar er ikke en fejl. "Der er ikke noget at foreslå" er et rigtigt svar
+// på begge spørgsmål, og en fejlmeddelelse ville lære folk, at funktionen er i
+// stykker, når den i virkeligheden var enig med dem.
+func (c *Client) suggestions(ctx context.Context, system, prompt string) ([]Suggestion, error) {
+	reply, err := c.Complete(ctx, system, []Message{{Role: "user", Content: prompt}})
+	if err != nil {
+		return nil, err
+	}
+
+	var out []Suggestion
+	if err := json.Unmarshal([]byte(extractJSON(reply)), &out); err != nil {
+		return nil, fmt.Errorf("ai: the model did not return a list: %s", truncate(reply, 200))
+	}
+
+	clean := make([]Suggestion, 0, len(out))
+	for _, s := range out {
+		s.Line = strings.TrimSpace(s.Line)
+		s.Why = strings.TrimSpace(s.Why)
+		if s.Line != "" {
+			clean = append(clean, s)
+		}
+	}
+	return clean, nil
+}
+
+// languageOf er det sprog, svaret skal skrives i. Ét sted, fordi det ellers er
+// den slags, der bliver rettet ét sted ud af fire.
+func languageOf(locale string) string {
+	if strings.HasPrefix(strings.ToLower(locale), "en") {
+		return "English"
+	}
+	return "Danish"
+}
+
 // extractJSON pulls an array out of a reply that may have been wrapped in a code
 // fence or preceded by a sentence, which models do however firmly they are asked
 // not to.

internal/httpapi/ai_suggest_handlers.go

@@ -0,0 +1,370 @@
+package httpapi
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+
+	"github.com/kristianwind/verdande/internal/ai"
+	"github.com/kristianwind/verdande/internal/quickadd"
+	"github.com/kristianwind/verdande/internal/store"
+)
+
+// AI'ens forslag, og hvad der sker med dem.
+//
+// Fælles for det hele: modellen skriver ikke noget. Den foreslår en *linje* i den
+// syntaks, man selv skriver i — "Ring til Anders i morgen p1 #Firma" — og
+// forslaget bliver til noget, når nogen siger ja til det. Det er ikke
+// forsigtighed for forsigtighedens skyld: en model, der retter i folks opgaver
+// direkte, skal have ret hver gang for at være til gavn, hvor en, der foreslår,
+// skal have ret tit nok til at spare et par tastetryk.
+//
+// Og linjen er quick-add-syntaks frem for et felt pr. egenskab, fordi parseren
+// findes: der er én fortolkning af "i morgen" i dette program, og forslaget går
+// gennem den samme som alt andet.
+
+// aiSuggestionJSON er ét forslag på vej til fladen.
+type aiSuggestionJSON struct {
+	// TaskID er sat, når forslaget handler om en opgave, der allerede findes —
+	// altså ved oprydningen i indbakken. Tomt, når forslaget er en ny opgave.
+	TaskID string `json:"task_id,omitempty"`
+	Line   string `json:"line"`
+	Why    string `json:"why,omitempty"`
+}
+
+// aiClientFor er de tre linjer, hver eneste AI-funktion ellers ville gentage:
+// hent opsætningen, og sig pænt fra, når der ikke er nogen.
+func (s *Server) aiClientFor(w http.ResponseWriter, r *http.Request) (*ai.Client, bool) {
+	cfg, err := s.aiConfig(r, userFrom(r.Context()).ID)
+	if err != nil {
+		s.internal(w, r, "ai settings", err)
+		return nil, false
+	}
+	if !cfg.Configured() {
+		// Ikke en fejl, nogen har lavet: funktionen er slået fra, indtil man
+		// lægger sin egen nøgle ind.
+		writeError(w, http.StatusConflict, CodeAINotConfigured, "no AI provider is configured")
+		return nil, false
+	}
+	return ai.New(cfg), true
+}
+
+// projectNames er de projekter, modellen må nævne.
+//
+// Givet med frem for udeladt, fordi alternativet er, at den finder på et: et
+// `#Nyt projekt`, ingen har, ville lave et projekt ved et uheld, første gang
+// nogen sagde ja til forslaget.
+func (s *Server) projectNames(r *http.Request) []string {
+	projects, err := s.db.ListProjects(r.Context(), userFrom(r.Context()).ID, false)
+	if err != nil {
+		s.log.Warn("projects for ai", "err", err)
+		return nil
+	}
+	out := make([]string, 0, len(projects))
+	for _, p := range projects {
+		if p.IsInbox {
+			continue
+		}
+		out = append(out, p.Name)
+	}
+	return out
+}
+
+// handleAITidyInbox foreslår, hvordan det, der ligger løst i indbakken, kunne
+// skrives færdig.
+//
+// Indbakken er der, hvor ting lander, når man ikke havde tid til at skrive dem
+// ordentligt — og den er derfor også der, hvor de bliver liggende. At åbne hver
+// enkelt og sætte projekt, dato og prioritet er ti klik pr. linje; det her er ét
+// spørgsmål og et ja pr. linje.
+func (s *Server) handleAITidyInbox(w http.ResponseWriter, r *http.Request) {
+	user := userFrom(r.Context())
+	client, ok := s.aiClientFor(w, r)
+	if !ok {
+		return
+	}
+
+	inbox, err := s.db.InboxID(r.Context(), user.ID)
+	if err != nil {
+		s.internal(w, r, "inbox", err)
+		return
+	}
+	tasks, err := s.db.ListTasks(r.Context(), user.ID, store.TaskFilter{
+		ProjectIDs: []string{inbox}, Limit: 50,
+	})
+	if err != nil {
+		s.internal(w, r, "list inbox", err)
+		return
+	}
+	if len(tasks) == 0 {
+		writeJSON(w, http.StatusOK, map[string]any{"suggestions": []aiSuggestionJSON{}})
+		return
+	}
+
+	// Nummereret, så svaret kan lægges tilbage på den rigtige opgave. Modellen
+	// bliver bedt om at svare i rækkefølge, men en model, der springer en over,
+	// må ikke kunne flytte alle de andres forslag én plads — derfor står
+	// nummeret i teksten og bliver læst tilbage.
+	lines := make([]string, 0, len(tasks))
+	for i, t := range tasks {
+		line := strconv.Itoa(i+1) + ". " + t.Content
+		if t.Description != "" {
+			line += " — " + firstWords(t.Description, 30)
+		}
+		lines = append(lines, line)
+	}
+
+	ctx, cancel := contextWithTimeout(r, 90*time.Second)
+	defer cancel()
+
+	today := time.Now().In(userLocation(user.Timezone)).Format("2006-01-02")
+	suggestions, err := client.TidyInbox(ctx, lines, s.projectNames(r), today, user.Locale)
+	if err != nil {
+		s.log.Warn("ai tidy inbox", "err", err)
+		writeError(w, StatusUpstreamRefused, CodeInternal, err.Error())
+		return
+	}
+
+	out := make([]aiSuggestionJSON, 0, len(suggestions))
+	for i, sug := range suggestions {
+		n, line := numberedLine(sug.Line)
+		// Uden et nummer falder vi tilbage på rækkefølgen, som er det, der blev
+		// bedt om. Med et nummer, der ikke findes, springes forslaget over —
+		// et forslag, der peger på en opgave, der ikke er der, er ikke et forslag.
+		if n == 0 {
+			n = i + 1
+		}
+		if n < 1 || n > len(tasks) {
+			continue
+		}
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		out = append(out, aiSuggestionJSON{TaskID: tasks[n-1].ID, Line: line, Why: sug.Why})
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"suggestions": out})
+}
+
+type applyLineRequest struct {
+	TaskID string `json:"task_id"`
+	Line   string `json:"line"`
+}
+
+// handleAIApplyToTask skriver ét accepteret forslag ind i den opgave, det handler
+// om.
+//
+// Parsningen sker her og ikke i browseren, så "i morgen" betyder det samme, som
+// det gør alle andre steder i programmet — og så et forslag, der er blevet rettet
+// i hånden, inden det blev sagt ja til, bliver læst på nøjagtig samme måde som et,
+// der ikke blev rørt.
+func (s *Server) handleAIApplyToTask(w http.ResponseWriter, r *http.Request) {
+	var req applyLineRequest
+	if err := decodeJSON(w, r, &req); err != nil {
+		return
+	}
+	user := userFrom(r.Context())
+	if strings.TrimSpace(req.Line) == "" {
+		writeFieldErrors(w, map[string]string{"line": "required"})
+		return
+	}
+
+	task, err := s.db.GetTask(r.Context(), req.TaskID, user.ID)
+	if err != nil {
+		s.storeError(w, r, "get task", err)
+		return
+	}
+
+	loc := userLocation(user.Timezone)
+	parsed := quickadd.Parse(req.Line, time.Now().In(loc), user.Locale)
+	if strings.TrimSpace(parsed.Content) == "" {
+		writeFieldErrors(w, map[string]string{"line": "there is no task in that"})
+		return
+	}
+
+	// Kun det, linjen faktisk siger. En tom dato i et forslag betyder "der stod
+	// ikke noget om en dato" og ikke "fjern den, der er" — modellen er blevet bedt
+	// om at lade være med at gætte datoer, og så må et manglende gæt heller ikke
+	// slette noget.
+	update := store.TaskUpdate{Content: &parsed.Content}
+	if parsed.Priority != 0 {
+		update.Priority = &parsed.Priority
+	}
+	if parsed.DueDate != "" {
+		update.SetDue, update.DueDate = true, parsed.DueDate
+	}
+	if parsed.Recurrence != "" {
+		update.RecurrenceRule = &parsed.Recurrence
+	}
+	if len(parsed.Labels) > 0 {
+		update.Labels, update.SetLabels = parsed.Labels, true
+	}
+	if err := s.db.UpdateTask(r.Context(), task.ID, user.ID, update); err != nil {
+		s.storeError(w, r, "update task", err)
+		return
+	}
+
+	// Et projekt, modellen fandt på, flytter ingenting. Den fik listen over dem,
+	// der findes, og et navn uden for den er et gæt — og et gæt må ikke kunne
+	// lave et projekt eller flytte en opgave hen, hvor ejeren ikke leder.
+	if parsed.Project != "" {
+		if id, err := s.db.ProjectByName(r.Context(), user.ID, parsed.Project); err == nil && id != task.ProjectID {
+			if _, err := store.RequireProjectRole(r.Context(), s.db, id, user.ID, store.RoleEditor); err == nil {
+				if _, err := s.db.MoveTask(r.Context(), task.ID, id, "", "", ""); err != nil {
+					s.internal(w, r, "move task", err)
+					return
+				}
+			}
+		}
+	}
+
+	updated, err := s.db.GetTask(r.Context(), task.ID, user.ID)
+	if err != nil {
+		s.storeError(w, r, "get task", err)
+		return
+	}
+	s.publish(updated.ProjectID, "task.updated", toTaskJSON(*updated))
+	writeJSON(w, http.StatusOK, toTaskJSON(*updated))
+}
+
+// handleAINoteActions trækker det, nogen har lovet, ud af en note.
+//
+// Et referat er fuldt af sætninger, der ligner opgaver, og af tre, der er det.
+// Modellen bliver bedt om kun at tage dem, nogen har forpligtet sig på, og om at
+// citere de ord, den tog dem fra — så et forkert punkt kan gennemskues frem for
+// bare at være forkert.
+func (s *Server) handleAINoteActions(w http.ResponseWriter, r *http.Request) {
+	user := userFrom(r.Context())
+	client, ok := s.aiClientFor(w, r)
+	if !ok {
+		return
+	}
+
+	n, err := s.db.Note(r.Context(), chi.URLParam(r, "noteID"))
+	if err != nil {
+		s.internal(w, r, "get note", err)
+		return
+	}
+	if n == nil || !s.mayTouchNote(r, n, store.RoleViewer) {
+		writeError(w, http.StatusNotFound, CodeNotFound, "no such note")
+		return
+	}
+	if strings.TrimSpace(n.Body) == "" {
+		writeJSON(w, http.StatusOK, map[string]any{"suggestions": []aiSuggestionJSON{}})
+		return
+	}
+
+	ctx, cancel := contextWithTimeout(r, 90*time.Second)
+	defer cancel()
+
+	today := time.Now().In(userLocation(user.Timezone)).Format("2006-01-02")
+	suggestions, err := client.ActionsInNote(ctx, n.Body, s.projectNames(r), today, user.Locale)
+	if err != nil {
+		s.log.Warn("ai note actions", "err", err)
+		writeError(w, StatusUpstreamRefused, CodeInternal, err.Error())
+		return
+	}
+
+	out := make([]aiSuggestionJSON, 0, len(suggestions))
+	for _, sug := range suggestions {
+		out = append(out, aiSuggestionJSON{Line: sug.Line, Why: sug.Why})
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"suggestions": out})
+}
+
+// handleAICreateFromNote laver én accepteret opgave fra en note.
+//
+// Noten bliver ikke rørt. Det er fristende at skrive linket ind i den, så de to
+// peger på hinanden, men en tekst, et program skriver i uden at blive bedt om
+// det, er en tekst, man holder op med at stole på. I stedet bærer opgaven, hvor
+// den kom fra — og noten kan findes på sin titel.
+func (s *Server) handleAICreateFromNote(w http.ResponseWriter, r *http.Request) {
+	var req applyLineRequest
+	if err := decodeJSON(w, r, &req); err != nil {
+		return
+	}
+	user := userFrom(r.Context())
+
+	n, err := s.db.Note(r.Context(), chi.URLParam(r, "noteID"))
+	if err != nil {
+		s.internal(w, r, "get note", err)
+		return
+	}
+	if n == nil || !s.mayTouchNote(r, n, store.RoleViewer) {
+		writeError(w, http.StatusNotFound, CodeNotFound, "no such note")
+		return
+	}
+
+	loc := userLocation(user.Timezone)
+	parsed := quickadd.Parse(req.Line, time.Now().In(loc), user.Locale)
+	if strings.TrimSpace(parsed.Content) == "" {
+		writeFieldErrors(w, map[string]string{"line": "there is no task in that"})
+		return
+	}
+
+	// Notens eget projekt som udgangspunkt: står referatet i et projekt, hører
+	// det, der blev aftalt i det, som regel til samme sted. Et `#projekt` i
+	// linjen vinder, fordi det er valgt frem for arvet.
+	projectID := n.ProjectID
+	if parsed.Project != "" {
+		if id, err := s.db.ProjectByName(r.Context(), user.ID, parsed.Project); err == nil {
+			projectID = id
+		}
+	}
+	if projectID == "" {
+		if projectID, err = s.db.InboxID(r.Context(), user.ID); err != nil {
+			s.internal(w, r, "inbox", err)
+			return
+		}
+	}
+	if _, err := store.RequireProjectRole(r.Context(), s.db, projectID, user.ID, store.RoleEditor); err != nil {
+		writeError(w, http.StatusNotFound, CodeNotFound, "not found")
+		return
+	}
+
+	task := &store.Task{
+		ProjectID: projectID, Content: parsed.Content, Priority: parsed.Priority,
+		DueDate: parsed.DueDate, RecurrenceRule: parsed.Recurrence,
+		Description: "[[" + n.Title + "]]", CreatedBy: user.ID,
+	}
+	if err := s.db.CreateTask(r.Context(), task, parsed.Labels); err != nil {
+		s.internal(w, r, "create task from note", err)
+		return
+	}
+	s.publish(projectID, "task.created", toTaskJSON(*task))
+	writeJSON(w, http.StatusCreated, toTaskJSON(*task))
+}
+
+// numberedLine skiller "3. Ring til Anders" ad i nummeret og linjen.
+//
+// Nummeret er, hvordan et forslag finder tilbage til den opgave, det handler om.
+// Rækkefølgen alene ville også kunne bruges, og gør det som reserve — men en
+// model, der springer en opgave over, ville så flytte alle de følgende forslag
+// én plads, og så bliver "sæt dato på den her" sat på en anden.
+func numberedLine(s string) (int, string) {
+	s = strings.TrimSpace(s)
+	dot := strings.IndexByte(s, '.')
+	if dot <= 0 || dot > 3 {
+		return 0, s
+	}
+	n := 0
+	for _, c := range s[:dot] {
+		if c < '0' || c > '9' {
+			return 0, s
+		}
+		n = n*10 + int(c-'0')
+	}
+	return n, strings.TrimSpace(s[dot+1:])
+}
+
+// firstWords klipper en beskrivelse ned til noget, der kan stå i en prompt uden at
+// fylde den med en hel note.
+func firstWords(s string, n int) string {
+	fields := strings.Fields(s)
+	if len(fields) <= n {
+		return strings.Join(fields, " ")
+	}
+	return strings.Join(fields[:n], " ") + " …"
+}

internal/httpapi/ai_suggest_test.go

@@ -0,0 +1,189 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// fakeModel er en OpenAI-formet endpoint, der svarer med det, prøven har brug for.
+//
+// Den rigtige vej hele vejen igennem: indstillingerne, prompten, parsningen af
+// svaret og skrivningen bagefter. Det, der er værd at prøve her, er ikke om en
+// model kan svare — det er, hvad der sker med svaret, når den har svaret noget.
+func fakeModel(t *testing.T, reply string) string {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"choices": []map[string]any{
+				{"message": map[string]string{"content": reply}},
+			},
+		})
+	}))
+	t.Cleanup(srv.Close)
+	return srv.URL
+}
+
+// useModel peger kontoen på den falske model. Kun en administrator må pege AI'en
+// på en adresse i det private net, og bootstrap-kontoen er en.
+func (ts *testServer) useModel(t *testing.T, url string) {
+	t.Helper()
+	resp, _ := ts.do(t, "PUT", "/api/v1/ai/settings", map[string]any{
+		"provider": "compatible", "base_url": url, "model": "prøvemodel",
+	})
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		t.Fatalf("gem ai-indstillinger: %d", resp.StatusCode)
+	}
+}
+
+// Forslaget peger tilbage på den opgave, det handler om — også når modellen
+// springer en over. Uden nummeret ville "sæt en dato på den her" lande på en
+// anden opgave end den, den blev skrevet om.
+func TestTidyingTheInboxSuggestsPerTask(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	ts.useModel(t, fakeModel(t, `[
+		{"line": "2. Ring til Anders i morgen p1", "why": "der står et navn og et telefonnummer"}
+	]`))
+
+	first := ts.quickTask(t, "noget som helst")
+	second := ts.quickTask(t, "anders 12345678")
+
+	resp, out := ts.do(t, "POST", "/api/v1/ai/inbox/tidy", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("ryd op: %d %v", resp.StatusCode, out)
+	}
+	list, _ := out["suggestions"].([]any)
+	if len(list) != 1 {
+		t.Fatalf("forslag = %v, want ét", list)
+	}
+	sug := list[0].(map[string]any)
+	if sug["task_id"] != second {
+		t.Errorf("forslaget peger på %v, want den anden opgave (%v)", sug["task_id"], second)
+	}
+	if sug["line"] != "Ring til Anders i morgen p1" {
+		t.Errorf("nummeret blev ikke taget af linjen: %v", sug["line"])
+	}
+	if sug["why"] == "" {
+		t.Error("forslaget siger ikke hvorfor")
+	}
+	_ = first
+}
+
+// Et ja skriver forslaget ind i opgaven — gennem den samme parser som alt andet,
+// så "i morgen" betyder det samme her som i feltet øverst i fladen.
+func TestAcceptingASuggestionWritesItIntoTheTask(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	ts.useModel(t, fakeModel(t, `[]`))
+	taskID := ts.quickTask(t, "anders")
+
+	resp, out := ts.do(t, "POST", "/api/v1/ai/inbox/tidy/apply", map[string]any{
+		"task_id": taskID, "line": "Ring til Anders i morgen p1",
+	})
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("accepter: %d %v", resp.StatusCode, out)
+	}
+	if out["content"] != "Ring til Anders" {
+		t.Errorf("indhold = %v", out["content"])
+	}
+	if out["priority"] != float64(1) {
+		t.Errorf("prioritet = %v, want 1", out["priority"])
+	}
+	if out["due_date"] == nil || out["due_date"] == "" {
+		t.Errorf("datoen blev ikke sat: %v", out["due_date"])
+	}
+}
+
+// Et projekt, modellen har fundet på, flytter ingenting. Den fik listen over dem,
+// der findes, og et navn uden for den er et gæt — et gæt må ikke kunne flytte en
+// opgave hen, hvor ejeren ikke leder efter den.
+func TestAnInventedProjectDoesNotMoveTheTask(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	ts.useModel(t, fakeModel(t, `[]`))
+	taskID := ts.quickTask(t, "anders")
+
+	_, before := ts.do(t, "GET", "/api/v1/tasks/"+taskID, nil)
+	resp, after := ts.do(t, "POST", "/api/v1/ai/inbox/tidy/apply", map[string]any{
+		"task_id": taskID, "line": "Ring til Anders #EtProjektDerIkkeFindes",
+	})
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("accepter: %d", resp.StatusCode)
+	}
+	if after["project_id"] != before["project_id"] {
+		t.Errorf("opgaven blev flyttet til %v (var %v)", after["project_id"], before["project_id"])
+	}
+}
+
+// En note bliver ikke rørt, når der bliver lavet opgaver ud af den. En tekst, et
+// program skriver i uden at blive bedt om det, er en tekst, man holder op med at
+// stole på.
+func TestTasksFromANoteLeaveTheNoteAlone(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	ts.useModel(t, fakeModel(t, `[
+		{"line": "Send prisliste til Anders på fredag", "why": "“jeg sender prislisten fredag”"}
+	]`))
+
+	body := "# Møde med Anders\njeg sender prislisten fredag"
+	noteID := ts.createNote(t, body)
+
+	resp, out := ts.do(t, "POST", "/api/v1/ai/notes/"+noteID+"/actions", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("find opgaver: %d %v", resp.StatusCode, out)
+	}
+	list, _ := out["suggestions"].([]any)
+	if len(list) != 1 {
+		t.Fatalf("forslag = %v, want ét", list)
+	}
+	line := list[0].(map[string]any)["line"].(string)
+
+	resp, task := ts.do(t, "POST", "/api/v1/ai/notes/"+noteID+"/actions/apply",
+		map[string]any{"line": line})
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("accepter: %d %v", resp.StatusCode, task)
+	}
+	if task["content"] != "Send prisliste til Anders" {
+		t.Errorf("opgave = %v", task["content"])
+	}
+	// Opgaven bærer, hvor den kom fra, som et notelink.
+	if task["description"] != "[[Møde med Anders]]" {
+		t.Errorf("beskrivelse = %v, want et link til noten", task["description"])
+	}
+
+	_, note := ts.do(t, "GET", "/api/v1/notes/"+noteID, nil)
+	if note["body"] != body {
+		t.Errorf("noten blev rettet:\n%v", note["body"])
+	}
+}
+
+// Uden en model er funktionen slået fra — ikke i stykker. Svaret skal kunne
+// kendes fra en fejl, så fladen kan sige "læg din nøgle ind" frem for "der skete
+// noget".
+func TestSuggestionsAreOffWithoutAModel(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	for _, path := range []string{"/api/v1/ai/inbox/tidy"} {
+		if resp, _ := ts.do(t, "POST", path, nil); resp.StatusCode != http.StatusConflict {
+			t.Errorf("%s gav %d, want 409", path, resp.StatusCode)
+		}
+	}
+}
+
+// quickTask lægger en linje i indbakken gennem den samme vej som feltet øverst.
+func (ts *testServer) quickTask(t *testing.T, text string) string {
+	t.Helper()
+	resp, out := ts.do(t, "POST", "/api/v1/tasks/quick-add", map[string]any{"text": text})
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("quickadd %q: %d %v", text, resp.StatusCode, out)
+	}
+	id, _ := out["id"].(string)
+	if id == "" {
+		t.Fatalf("quickadd gav intet id: %v", out)
+	}
+	return id
+}

internal/httpapi/inbound_hook_test.go

@@ -0,0 +1,194 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// doRaw sender en krop, der ikke er JSON — en genvej på en telefon sender ren
+// tekst, og en webhook-formular sender felter. Det er halvdelen af det, der
+// prøves her.
+func (ts *testServer) doRaw(t *testing.T, method, path, contentType, body string) (*http.Response, map[string]any) {
+	t.Helper()
+	req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
+	if err != nil {
+		t.Fatalf("build request: %v", err)
+	}
+	req.Header.Set("Content-Type", contentType)
+	resp, err := ts.client.Do(req)
+	if err != nil {
+		t.Fatalf("%s %s: %v", method, path, err)
+	}
+	t.Cleanup(func() { resp.Body.Close() })
+
+	var decoded map[string]any
+	raw, _ := io.ReadAll(resp.Body)
+	if len(raw) > 0 {
+		_ = json.Unmarshal(raw, &decoded)
+	}
+	return resp, decoded
+}
+
+// hookURL henter personens egen krog-adresse, som fladen viser den.
+func (ts *testServer) hookURL(t *testing.T) string {
+	t.Helper()
+	resp, out := ts.do(t, "GET", "/api/v1/hook-url", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("hent krog-URL: %d", resp.StatusCode)
+	}
+	url, _ := out["url"].(string)
+	if !strings.Contains(url, "/inbound/hook/") {
+		t.Fatalf("url = %q", url)
+	}
+	return url
+}
+
+// hookPath er stien, testserveren kan kaldes på — URL'en er absolut, fordi den
+// skal kunne kopieres ind i en genvej på en telefon.
+func hookPath(url string) string {
+	return url[strings.Index(url, "/inbound/hook/"):]
+}
+
+// En linje ren tekst, skubbet ind udefra, bliver til en opgave i indbakken — og
+// betyder det samme, som den ville betyde i feltet øverst i fladen.
+func TestAPushFromAnotherAppLandsInTheInbox(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+
+	anon := newSignedOut(t, ts)
+	resp, out := anon.doRaw(t, "POST", path, "text/plain",
+		"Ring til Anders p1\nhan ringede i går")
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("skub: %d, %v", resp.StatusCode, out)
+	}
+
+	_, list := ts.do(t, "GET", "/api/v1/tasks", nil)
+	tasks, _ := list["tasks"].([]any)
+	var found map[string]any
+	for _, raw := range tasks {
+		task := raw.(map[string]any)
+		if task["content"] == "Ring til Anders" {
+			found = task
+		}
+	}
+	if found == nil {
+		t.Fatalf("opgaven kom ikke i indbakken: %v", tasks)
+	}
+	// Parseren er den samme som fladens: p1 er en prioritet og ikke en del af
+	// teksten, og resten af kroppen står under opgaven.
+	if found["priority"] != float64(1) {
+		t.Errorf("prioritet = %v, want 1", found["priority"])
+	}
+	if found["description"] != "han ringede i går" {
+		t.Errorf("beskrivelse = %v", found["description"])
+	}
+}
+
+// JSON fra en tjeneste, med de feltnavne folk faktisk sender.
+func TestTheHookReadsJSON(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+	anon := newSignedOut(t, ts)
+
+	for _, body := range []string{
+		`{"text": "Køb mælk"}`,
+		`{"title": "Køb mælk"}`,
+		`{"content": "Køb mælk"}`,
+	} {
+		resp, out := anon.doRaw(t, "POST", path, "application/json", body)
+		if resp.StatusCode != http.StatusCreated {
+			t.Fatalf("%s: %d, %v", body, resp.StatusCode, out)
+		}
+		if out["content"] != "Køb mælk" {
+			t.Errorf("%s gav %v", body, out["content"])
+		}
+	}
+
+	// En krop, der siger JSON og ikke er det, læses ikke som tekst bagefter: en
+	// opgave, der hedder `{"txt": …}`, er en dårligere fejlmeddelelse end et 422.
+	resp, _ := anon.doRaw(t, "POST", path, "application/json", `{"txt": "skrevet forkert"}`)
+	if resp.StatusCode != http.StatusUnprocessableEntity {
+		t.Errorf("forkert JSON gav %d, want 422", resp.StatusCode)
+	}
+}
+
+// Et token, der ikke findes, er det samme svar som et, der aldrig har eksisteret.
+// Alt andet er en maskine til at gætte tokens med.
+func TestAnUnknownHookTokenIsNotFound(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	anon := newSignedOut(t, ts)
+
+	resp, _ := anon.doRaw(t, "POST", "/inbound/hook/deteringentingogsaaslet", "text/plain", "hej")
+	if resp.StatusCode != http.StatusNotFound {
+		t.Fatalf("ukendt token gav %d, want 404", resp.StatusCode)
+	}
+}
+
+// Den gamle URL holder op med at virke, når man skifter den. Det er den eneste vej
+// tilbage: adressen står i en genvej på en telefon eller i et script.
+func TestRotatingTheHookRetiresTheOldURL(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	old := hookPath(ts.hookURL(t))
+
+	resp, out := ts.do(t, "POST", "/api/v1/hook-url/rotate", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("skift: %d", resp.StatusCode)
+	}
+	fresh := hookPath(out["url"].(string))
+	if fresh == old {
+		t.Fatal("den nye URL er den gamle")
+	}
+
+	anon := newSignedOut(t, ts)
+	if resp, _ := anon.doRaw(t, "POST", old, "text/plain", "gammel"); resp.StatusCode != http.StatusNotFound {
+		t.Errorf("den gamle URL virker stadig: %d", resp.StatusCode)
+	}
+	if resp, _ := anon.doRaw(t, "POST", fresh, "text/plain", "ny"); resp.StatusCode != http.StatusCreated {
+		t.Errorf("den nye URL virker ikke: %d", resp.StatusCode)
+	}
+}
+
+// Ingen tekst er ikke en opgave. En tom opgave i indbakken er værre end en fejl,
+// fordi den ser ud som om integrationen virker.
+func TestAnEmptyPushIsRefused(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+	anon := newSignedOut(t, ts)
+
+	resp, _ := anon.doRaw(t, "POST", path, "text/plain", "   \n  ")
+	if resp.StatusCode != http.StatusUnprocessableEntity {
+		t.Fatalf("tom tekst gav %d, want 422", resp.StatusCode)
+	}
+}
+
+// Et token kan én ting. Det ligger i et script på en anden maskine, og hvad der
+// ellers kan nås med det, er hvad der er sluppet ud sammen med det.
+func TestTheHookTokenIsNotAnAPIToken(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	url := ts.hookURL(t)
+	token := url[strings.LastIndex(url, "/")+1:]
+
+	anon := newSignedOut(t, ts)
+	req, err := http.NewRequest("GET", anon.URL+"/api/v1/tasks", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	resp, err := anon.client.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		t.Fatal("krog-tokenet gav adgang til API'et")
+	}
+}

internal/httpapi/integrations_handlers.go

@@ -2,7 +2,9 @@ package httpapi
 
 import (
 	"encoding/json"
+	"io"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 
@@ -155,6 +157,191 @@ func (s *Server) handleInboundMail(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, map[string]string{"task_id": task.ID})
 }
 
+// --- en krog ind i indbakken --------------------------------------------------------
+
+type hookURLResponse struct {
+	URL string `json:"url"`
+}
+
+// handleGetHookURL returns the personal address another program can push a task
+// to, minting the token on first ask.
+//
+// Der var to veje ind i forvejen, og ingen af dem passer til "gem den her, mens
+// jeg står med telefonen i hånden". API-tokenet giver adgang til alt og skal have
+// en JSON-krop skrevet rigtigt; mailadressen virker først, når nogen har sat en
+// mailserver op. Det, der manglede, var en URL, man kan smide en linje tekst efter
+// — fra en genvej på telefonen, et script, en anden tjeneste.
+func (s *Server) handleGetHookURL(w http.ResponseWriter, r *http.Request) {
+	token, err := s.db.EnsureHookToken(r.Context(), userFrom(r.Context()).ID)
+	if err != nil {
+		s.internal(w, r, "hook token", err)
+		return
+	}
+	writeJSON(w, http.StatusOK, hookURLResponse{URL: s.hookURL(token)})
+}
+
+// handleRotateHookURL mints a new one and retires the old.
+//
+// Den eneste vej tilbage, når en URL er sluppet ud: den står i en genvej på en
+// telefon eller i et script på en anden maskine, og der er ikke andet at trække
+// tilbage end tokenet selv.
+func (s *Server) handleRotateHookURL(w http.ResponseWriter, r *http.Request) {
+	token, err := auth.NewToken()
+	if err != nil {
+		s.internal(w, r, "generate hook token", err)
+		return
+	}
+	if err := s.db.SetHookToken(r.Context(), userFrom(r.Context()).ID, token); err != nil {
+		s.internal(w, r, "set hook token", err)
+		return
+	}
+	writeJSON(w, http.StatusOK, hookURLResponse{URL: s.hookURL(token)})
+}
+
+func (s *Server) hookURL(token string) string {
+	return strings.TrimSuffix(s.cfg.BaseURL, "/") + "/inbound/hook/" + token
+}
+
+type hookRequest struct {
+	// Text er linjen, der bliver til opgaven. `title` og `content` tages med som
+	// de samme, fordi det er dem, andre tjenester i forvejen kalder feltet — og en
+	// integration, der fejler på et feltnavn, fejler tavst hos den, der satte den
+	// op.
+	Text    string `json:"text"`
+	Title   string `json:"title"`
+	Content string `json:"content"`
+	// Note er det, der står under opgaven. `body` og `description` ligeså.
+	Note        string `json:"note"`
+	Body        string `json:"body"`
+	Description string `json:"description"`
+}
+
+func (h hookRequest) line() string {
+	for _, v := range []string{h.Text, h.Title, h.Content} {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func (h hookRequest) note() string {
+	for _, v := range []string{h.Note, h.Body, h.Description} {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+// handleInboundHook turns a POST from somewhere else into a task in the inbox.
+//
+// Tokenet i stien er hele legitimationen, som i kalenderfeedet og den indgående
+// post: den, der kalder, er et script eller en genvej på en telefon, og hverken
+// kan logge ind. Derfor kan et token herfra også kun én ting — lave en opgave i
+// den ene persons indbakke — hvor et API-token kan alt.
+//
+// Kroppen læses på tre måder, fordi de tre er dem, man møder: JSON fra en
+// tjeneste, et formularfelt fra en webhook-formular, og ren tekst fra en genvej,
+// der bare sender det, man har markeret. Første linje bliver til opgaven, resten
+// til noten under den — det er sådan, en tekst, man har delt, ser ud.
+//
+// Linjen læses med quick-add-parseren, så "Ring til Anders i morgen p1 #Firma"
+// betyder det samme her som i feltet øverst i fladen. Det er hele pointen med at
+// have én parser: den vej, teksten kom ind ad, ændrer ikke, hvad den betyder.
+func (s *Server) handleInboundHook(w http.ResponseWriter, r *http.Request) {
+	user, err := s.db.UserByHookToken(r.Context(), chi.URLParam(r, "token"))
+	if err != nil {
+		// Samme svar som en adresse, der aldrig har eksisteret: et endpoint, der
+		// kender forskel, er en maskine til at gætte tokens med.
+		writeError(w, http.StatusNotFound, CodeNotFound, "no such address")
+		return
+	}
+
+	line, note := s.readHookBody(r)
+	if strings.TrimSpace(line) == "" {
+		writeFieldErrors(w, map[string]string{"text": "required"})
+		return
+	}
+
+	parsed := quickadd.Parse(line, time.Now().In(userLocation(user.Timezone)), user.Locale)
+	content := parsed.Content
+	if strings.TrimSpace(content) == "" {
+		content = line
+	}
+
+	projectID := ""
+	if parsed.Project != "" {
+		if id, err := s.db.ProjectByName(r.Context(), user.ID, parsed.Project); err == nil {
+			projectID = id
+		}
+	}
+	if projectID == "" {
+		if projectID, err = s.db.InboxID(r.Context(), user.ID); err != nil {
+			s.internal(w, r, "inbox", err)
+			return
+		}
+	}
+
+	task := &store.Task{
+		ProjectID: projectID, Content: content, Priority: parsed.Priority,
+		Description: strings.TrimSpace(note), DueDate: parsed.DueDate,
+		RecurrenceRule: parsed.Recurrence, CreatedBy: user.ID,
+	}
+	if err := s.db.CreateTask(r.Context(), task, parsed.Labels); err != nil {
+		s.internal(w, r, "create task from hook", err)
+		return
+	}
+
+	s.publish(projectID, "task.created", toTaskJSON(*task))
+	s.log.Info("task created from hook", "user", user.ID)
+	writeJSON(w, http.StatusCreated, map[string]string{"task_id": task.ID, "content": task.Content})
+}
+
+// readHookBody er de tre måder, en linje tekst kommer ind ad.
+//
+// Rækkefølgen er efter, hvor sikkert man ved, hvad man har: en erklæret
+// Content-Type tros, og ellers falder det tilbage på ren tekst — som er det, en
+// genvej på en telefon sender, når den ikke er blevet bedt om andet.
+//
+// En krop, der siger JSON, men ikke er det, læses ikke som tekst bagefter. Den,
+// der satte integrationen op, har skrevet noget forkert, og en opgave, der hedder
+// `{"txt": "køb mælk"}`, er en dårligere måde at finde ud af det på end et 422.
+func (s *Server) readHookBody(r *http.Request) (line, note string) {
+	const maxBody = 64 << 10
+	body, err := io.ReadAll(io.LimitReader(r.Body, maxBody))
+	if err != nil {
+		return "", ""
+	}
+	kind := r.Header.Get("Content-Type")
+
+	switch {
+	case strings.Contains(kind, "application/json"):
+		var req hookRequest
+		if err := json.Unmarshal(body, &req); err != nil {
+			return "", ""
+		}
+		return req.line(), req.note()
+
+	case strings.Contains(kind, "application/x-www-form-urlencoded"):
+		values, err := url.ParseQuery(string(body))
+		if err != nil {
+			return "", ""
+		}
+		req := hookRequest{
+			Text: values.Get("text"), Title: values.Get("title"), Content: values.Get("content"),
+			Note: values.Get("note"), Body: values.Get("body"), Description: values.Get("description"),
+		}
+		return req.line(), req.note()
+	}
+
+	// Ren tekst: første linje er opgaven, resten står under den. Sådan ser en tekst,
+	// man har delt fra en anden app, ud — en overskrift og noget under.
+	text := strings.TrimSpace(string(body))
+	first, rest, _ := strings.Cut(text, "\n")
+	return first, strings.TrimSpace(rest)
+}
+
 // mailToken reads the token out of "Name <todo+TOKEN@domain>".
 func mailToken(address string) string {
 	if i := strings.LastIndex(address, "<"); i >= 0 {

internal/httpapi/notifications_handlers.go

@@ -237,7 +237,16 @@ func (s *Server) pushToUser(userID, title, body, projectID string) pushOutcome {
 	if projectID == "" {
 		target = "/"
 	}
-	payload := push.Payload{Title: title, Body: body, URL: target}
+	// Mærket på ikonet følger med beskeden. Talt her frem for i service-workeren,
+	// som ikke har nogen hukommelse mellem to opvågninger og derfor kun kunne lægge
+	// én til noget, den ikke kender — et mærke, der tæller sig selv op og aldrig
+	// ned. Fejler tællingen, sendes beskeden alligevel: en besked uden et tal er
+	// stadig en besked.
+	unread, err := s.db.UnreadNotificationCount(ctx, userID)
+	if err != nil {
+		s.log.Warn("unread count for push", "err", err)
+	}
+	payload := push.Payload{Title: title, Body: body, URL: target, Unread: unread}
 	subject := s.vapidSubject()
 	for _, sub := range subs {
 		err := push.Send(ctx, push.Subscription{

internal/httpapi/server.go

@@ -66,6 +66,7 @@ type Server struct {
 	// Sat kun af prøver; se icsClient().
 	icsFetch     *http.Client
 	mailLimiter  *limiter
+	hookLimiter  *limiter
 	resetLimiter *limiter
 	// Second factors are counted against the *account*, not the address. An
 	// address bucket is defeated by anybody with more than one address, which is
@@ -93,6 +94,7 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 		// day. Sixty a minute never touches real delivery and still puts a ceiling
 		// on the one public write path that has none.
 		mailLimiter:  newLimiter(60, time.Minute),
+		hookLimiter:  newLimiter(60, time.Minute),
 		resetLimiter: newLimiter(5, time.Hour),
 		// Tighter than the password bucket, and for a whole hour. Somebody typing
 		// their own code gets it right on the first or second try; ten in an hour is
@@ -143,6 +145,20 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 	r.Method(http.MethodPost, "/inbound/mail",
 		s.rateLimit(s.mailLimiter, http.HandlerFunc(s.handleInboundMail)))
 
+	// En krog ind i indbakken: en URL, et andet program kan skubbe en linje tekst
+	// til. Uden for /api/v1 og uden for sessionen af samme grund som feedet og
+	// posten ovenfor — den, der kalder, er en genvej på en telefon eller et script,
+	// og kan ikke logge ind, så tokenet i stien er hele legitimationen.
+	//
+	// Kun POST. En GET ville være nemmere at kalde, og det er præcis problemet:
+	// forudindlæsning i en browser, en linkkontrol i en chat og en historik, der
+	// bliver besøgt igen, ville alle lave opgaver, ingen har bedt om.
+	//
+	// Sin egen kvote frem for postens: en travl integration skal ikke kunne lukke
+	// for den indgående post, og omvendt.
+	r.Method(http.MethodPost, "/inbound/hook/{token}",
+		s.rateLimit(s.hookLimiter, http.HandlerFunc(s.handleInboundHook)))
+
 	// MCP with the token in the query string, for clients that cannot send a
 	// header. Claude's custom-connector dialog takes a URL and nothing else, so
 	// /api/v1/mcp — which wants Authorization: Bearer — cannot be configured from
@@ -319,6 +335,9 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 			r.Get("/mail-address", s.handleGetMailAddress)
 			r.Post("/mail-address/rotate", s.handleRotateMailAddress)
 
+			r.Get("/hook-url", s.handleGetHookURL)
+			r.Post("/hook-url/rotate", s.handleRotateHookURL)
+
 			// Personal API tokens. Behind requireSession rather than the ambient
 			// auth: a token must not be able to mint or revoke another.
 			r.Route("/tokens", func(r chi.Router) {
@@ -333,6 +352,13 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 				r.Put("/settings", s.handleSetAISettings)
 				r.Post("/summary", s.handleAISummary)
 				r.Post("/tasks/{taskID}/split", s.handleAISplit)
+				// Forslag, ikke skrivninger. De to første svarer med linjer i
+				// quick-add-syntaks, som fladen viser frem; de to sidste er dét,
+				// der sker, når nogen siger ja til én af dem.
+				r.Post("/inbox/tidy", s.handleAITidyInbox)
+				r.Post("/inbox/tidy/apply", s.handleAIApplyToTask)
+				r.Post("/notes/{noteID}/actions", s.handleAINoteActions)
+				r.Post("/notes/{noteID}/actions/apply", s.handleAICreateFromNote)
 			})
 
 			r.Get("/version", s.handleVersion)

internal/push/push.go

@@ -56,6 +56,13 @@ type Payload struct {
 	Body  string `json:"body,omitempty"`
 	URL   string `json:"url,omitempty"`
 	Tag   string `json:"tag,omitempty"`
+	// Unread er tallet, mærket på appens ikon skal stå på, når beskeden lander.
+	//
+	// Sendt med frem for talt i service-workeren. Den har ingen hukommelse mellem
+	// to opvågninger, så den kan kun lægge én til noget, den ikke ved hvad er — og
+	// et mærke, der tæller sig selv op, kommer aldrig ned igen af sig selv. Tallet
+	// er serverens, og serveren ved det i forvejen.
+	Unread int `json:"unread,omitempty"`
 }
 
 var b64 = base64.RawURLEncoding

internal/push/push_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/ecdh"
 	"crypto/rand"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -64,3 +65,25 @@ func testVAPID(t *testing.T) VAPID {
 	}
 	return VAPID{Public: pub, Private: priv, Subject: "mailto:kristian@example.dk"}
 }
+
+// Tallet til mærket på ikonet skal med i beskeden — og skal blive væk, når der
+// ikke er noget at sige. Service-workeren læser netop det: er `unread` ikke et
+// tal, står mærket, som det stod, frem for at blive nulstillet af en tælling, der
+// ikke lykkedes.
+func TestPayloadCarriesTheUnreadCount(t *testing.T) {
+	with, err := json.Marshal(Payload{Title: "hej", Unread: 3})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(with), `"unread":3`) {
+		t.Errorf("payload = %s, want the unread count in it", with)
+	}
+
+	without, err := json.Marshal(Payload{Title: "hej"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(without), "unread") {
+		t.Errorf("payload = %s, want no count when there is none to send", without)
+	}
+}

internal/store/migrations/0035_en_krog_ind_i_indbakken.sql

@@ -0,0 +1,21 @@
+-- En personlig adresse, andre programmer kan skubbe en opgave ind ad.
+--
+-- Der var to veje ind i forvejen, og ingen af dem passer til "gem den her, mens
+-- jeg står med telefonen i hånden". API-tokenet giver adgang til alt og skal have
+-- en JSON-krop skrevet rigtigt; mailadressen virker først, når nogen har sat en
+-- mailserver op, og går gennem en indbakke, der kan være minutter om det. Det, der
+-- manglede, var en URL, man kan smide en linje tekst efter.
+--
+-- Sit eget token frem for at låne mailens. De to er den samme slags hemmelighed,
+-- men de bliver kompromitteret hver for sig: en URL, der har ligget i en genvej på
+-- en telefon, der blev væk, skal kunne skiftes uden at mailadressen — som står i
+-- andres adressebøger — skifter med. Og omvendt.
+--
+-- Ikke et API-token. Et token herfra kan én ting: lave en opgave i den persons
+-- indbakke. Det er hele forskellen på en hemmelighed, man kan lægge i et script på
+-- en anden maskine, og en, man ikke kan.
+ALTER TABLE users ADD COLUMN hook_token TEXT;
+
+-- Opslaget er "hvem er det her token", og det er også dét, der skal være entydigt:
+-- to konti med det samme token er to konti, en opgave kan lande i.
+CREATE UNIQUE INDEX idx_users_hook_token ON users (hook_token) WHERE hook_token IS NOT NULL;

internal/store/notifications.go

@@ -330,6 +330,52 @@ func (db *DB) SetMailToken(ctx context.Context, userID, token string) error {
 	return err
 }
 
+// --- krogen ind i indbakken ------------------------------------------------------
+
+// EnsureHookToken returns the token in the person's webhook URL, minting one the
+// first time it is asked for.
+//
+// Sit eget token frem for mailens. De to er den samme slags hemmelighed, men de
+// slipper ud hver for sig: en URL, der har ligget i en genvej på en telefon, der
+// blev væk, skal kunne skiftes uden at mailadressen — som står i andres
+// adressebøger — skifter med.
+func (db *DB) EnsureHookToken(ctx context.Context, userID string) (string, error) {
+	var token sql.NullString
+	err := db.QueryRowContext(ctx, `SELECT hook_token FROM users WHERE id = ?`, userID).Scan(&token)
+	if err != nil {
+		return "", err
+	}
+	if token.Valid && token.String != "" {
+		return token.String, nil
+	}
+
+	fresh, err := auth.NewToken()
+	if err != nil {
+		return "", err
+	}
+	if err := db.SetHookToken(ctx, userID, fresh); err != nil {
+		return "", err
+	}
+	return fresh, nil
+}
+
+func (db *DB) SetHookToken(ctx context.Context, userID, token string) error {
+	_, err := db.ExecContext(ctx,
+		`UPDATE users SET hook_token = ?, updated_at = ? WHERE id = ?`,
+		token, time.Now().Unix(), userID)
+	return err
+}
+
+// UserByHookToken is who a webhook call is on behalf of. Tokenet er hele
+// legitimationen, så et tomt et er et nej med det samme frem for et opslag, der
+// kunne ramme en række, hvor søjlen aldrig er sat.
+func (db *DB) UserByHookToken(ctx context.Context, token string) (*User, error) {
+	if token == "" {
+		return nil, ErrNotFound
+	}
+	return db.scanUser(ctx, `SELECT `+userColumns+` FROM users WHERE hook_token = ?`, token)
+}
+
 func (db *DB) UserByMailToken(ctx context.Context, token string) (*User, error) {
 	if token == "" {
 		return nil, ErrNotFound

web/src/lib/api.js

@@ -418,6 +418,11 @@ export const api = {
 	getMailAddress: () => get('/mail-address'),
 	rotateMailAddress: () => post('/mail-address/rotate'),
 
+	// Krogen ind i indbakken. Selve skubbet sker ikke herfra — det er et andet
+	// program, der gør det — så der er kun adressen at hente og at skifte.
+	getHookURL: () => get('/hook-url'),
+	rotateHookURL: () => post('/hook-url/rotate'),
+
 	getGmail: () => get('/gmail'),
 	setGmail: (data) => put('/gmail', data),
 	disconnectGmail: () => del('/gmail'),
@@ -472,6 +477,14 @@ export const api = {
 	setAISettings: (data) => put('/ai/settings', data),
 	aiSummary: () => post('/ai/summary'),
 	aiSplit: (taskId) => post(`/ai/tasks/${taskId}/split`),
+	// Forslag frem for skrivninger: de to første spørger, de to sidste er svaret
+	// på et ja. Linjen sendes med, som den står i feltet — den kan være rettet i
+	// hånden, inden den blev accepteret, og skal læses på samme måde som en, der
+	// ikke blev rørt.
+	aiTidyInbox: () => post('/ai/inbox/tidy'),
+	aiApplyToTask: (taskId, line) => post('/ai/inbox/tidy/apply', { task_id: taskId, line }),
+	aiNoteActions: (noteId) => post(`/ai/notes/${noteId}/actions`),
+	aiCreateFromNote: (noteId, line) => post(`/ai/notes/${noteId}/actions/apply`, { line }),
 
 	version: () => get('/version'),
 

web/src/lib/badge.js

@@ -0,0 +1,46 @@
+/**
+ * Mærket på appens ikon — tallet i Dock'en på en Mac, på proceslinjen på en pc.
+ *
+ * Klokken i hovedet siger det samme, men kun til den, der kigger på fanen. Det
+ * halve af pointen med at få besked er at få den, mens man laver noget andet, og
+ * det eneste sted, appen kan sige noget dér, er på sit eget ikon.
+ *
+ * Sat to steder, fordi der er to tilstande: her, mens appen er åben og selv ved
+ * hvor mange ulæste der er, og i service-workeren, når den ikke er — se `push`-
+ * lytteren i service-worker.js, som får tallet med i beskeden.
+ *
+ * Ét tal, ikke en optælling. Mærket sættes til hvad der *er*, aldrig til hvad der
+ * lige er kommet, så det kommer ned igen af sig selv, når beskederne bliver læst.
+ */
+
+/**
+ * Kan browseren mærke sit ikon? Safari og Chrome kan, når appen er lagt i Dock'en
+ * eller installeret; en almindelig fane har intet ikon at mærke, og kaldet gør
+ * ingenting. Firefox kan ikke endnu.
+ */
+export function supported() {
+	return typeof navigator !== 'undefined' && 'setAppBadge' in navigator;
+}
+
+/**
+ * Sætter mærket til `n`, eller fjerner det ved nul.
+ *
+ * Tavs, når det ikke kan lade sig gøre. Et mærke er en venlighed oven på klokken,
+ * der allerede står i fladen — ikke noget at afbryde nogen med, hvis browseren
+ * siger nej.
+ */
+export function setBadge(n) {
+	if (!supported()) return;
+	const count = Number(n) || 0;
+	try {
+		const done = count > 0 ? navigator.setAppBadge(count) : navigator.clearAppBadge();
+		done?.catch?.(() => {});
+	} catch {
+		// Nogle browsere kaster i stedet for at afvise. Det er det samme svar.
+	}
+}
+
+/** Fjerner mærket helt. Brugt ved log ud: den næste, der lander her, er en anden. */
+export function clearBadge() {
+	setBadge(0);
+}

web/src/lib/components/AISuggestions.svelte

@@ -0,0 +1,189 @@
+<script>
+	/**
+	 * En liste af forslag, man siger ja eller nej til, ét ad gangen.
+	 *
+	 * Den samme rude to steder — oprydning i indbakken og opgaver ud af en note —
+	 * fordi det er den samme handling: en model har foreslået en linje, og et
+	 * menneske bestemmer. To ruder ville betyde to svar på "hvad sker der, når
+	 * modellen tager fejl", og det spørgsmål har kun ét rigtigt svar.
+	 *
+	 * Forslaget står i et felt, man kan skrive i, frem for i en etiket. Det er
+	 * hele forskellen mellem at tage imod og at bestemme: et forslag, der er tæt
+	 * på, bliver rettet på to tegn i stedet for at blive kasseret — og linjen
+	 * læses af den samme parser bagefter, uanset om den blev rørt.
+	 *
+	 * `why` står under linjen, fordi et forkert gæt skal kunne gennemskues. "Fordi
+	 * der står 'inden fredag' i noten" er til at være uenig i; en dato, der bare
+	 * dukkede op, er ikke.
+	 */
+	import { t } from '$lib/i18n.svelte.js';
+	import { app } from '$lib/stores.svelte.js';
+	import { humanMessage } from '$lib/api.js';
+
+	let { title, hint, load, apply, onclose } = $props();
+
+	let state = $state('loading'); // loading | ready | failed
+	let error = $state('');
+	let rows = $state([]);
+	let busy = $state(null);
+
+	$effect(() => {
+		let alive = true;
+		state = 'loading';
+		load()
+			.then((r) => {
+				if (!alive) return;
+				rows = (r?.suggestions ?? []).map((s, i) => ({ ...s, key: i, line: s.line, done: false }));
+				state = 'ready';
+			})
+			.catch((e) => {
+				if (!alive) return;
+				error = humanMessage(e);
+				state = 'failed';
+			});
+		return () => {
+			alive = false;
+		};
+	});
+
+	async function accept(row) {
+		if (busy !== null) return;
+		busy = row.key;
+		try {
+			await apply(row, row.line);
+			rows = rows.map((r) => (r.key === row.key ? { ...r, done: true } : r));
+		} catch (e) {
+			app.toast(humanMessage(e));
+		} finally {
+			busy = null;
+		}
+	}
+
+	function skip(row) {
+		rows = rows.filter((r) => r.key !== row.key);
+	}
+
+	const left = $derived(rows.filter((r) => !r.done).length);
+</script>
+
+<section class="suggest">
+	<header>
+		<h3>{title}</h3>
+		<button class="close" onclick={onclose} aria-label={t('detail.close')}>×</button>
+	</header>
+
+	{#if state === 'loading'}
+		<p class="hint">{t('ai.thinking')}</p>
+	{:else if state === 'failed'}
+		<p class="hint bad">{error}</p>
+	{:else if !rows.length}
+		<p class="hint">{t('ai.nothingToSuggest')}</p>
+	{:else}
+		{#if hint}<p class="hint">{hint}</p>{/if}
+		<ul>
+			{#each rows as row (row.key)}
+				<li class:done={row.done}>
+					<input
+						value={row.line}
+						oninput={(e) => (row.line = e.currentTarget.value)}
+						disabled={row.done}
+						aria-label={title}
+					/>
+					{#if row.why}<p class="why">{row.why}</p>{/if}
+					{#if !row.done}
+						<div class="row">
+							<button class="button" disabled={busy !== null} onclick={() => accept(row)}>
+								{t('ai.accept')}
+							</button>
+							<button class="secondary" onclick={() => skip(row)}>{t('ai.skip')}</button>
+						</div>
+					{:else}
+						<p class="why ok">{t('ai.applied')}</p>
+					{/if}
+				</li>
+			{/each}
+		</ul>
+		{#if !left}
+			<p class="hint">{t('ai.allDone')}</p>
+		{/if}
+	{/if}
+</section>
+
+<style>
+	.suggest {
+		margin: var(--s2) 0;
+		padding: var(--s3);
+		border: 1px solid var(--line);
+		border-radius: var(--radius);
+		background: var(--surface-raised, var(--surface));
+	}
+
+	header {
+		display: flex;
+		align-items: baseline;
+		gap: var(--s2);
+	}
+
+	h3 {
+		margin: 0 0 var(--s2);
+		font-size: var(--text-sm);
+	}
+
+	.close {
+		margin-left: auto;
+		border: none;
+		background: none;
+		color: var(--ink-faint);
+		cursor: pointer;
+		font-size: var(--text-md);
+		line-height: 1;
+	}
+
+	.hint {
+		margin: 0 0 var(--s2);
+		font-size: var(--text-xs);
+		color: var(--ink-muted);
+		line-height: 1.5;
+	}
+
+	.hint.bad {
+		color: var(--danger, var(--ink));
+	}
+
+	ul {
+		list-style: none;
+		margin: 0;
+		padding: 0;
+		display: flex;
+		flex-direction: column;
+		gap: var(--s2);
+	}
+
+	li input {
+		width: 100%;
+		font-size: var(--text-sm);
+		padding: var(--s1);
+	}
+
+	li.done input {
+		opacity: 0.6;
+	}
+
+	/* Grunden til forslaget, under det. Mindre end linjen selv: det er baggrund
+	   for en beslutning, ikke selve beslutningen. */
+	.why {
+		margin: 2px 0 var(--s1);
+		font-size: var(--text-xs);
+		color: var(--ink-faint);
+		line-height: 1.4;
+	}
+
+	.why.ok {
+		color: var(--ok, var(--ink-muted));
+	}
+
+	.row {
+		display: flex;
+		gap: var(--s2);
+	}
+</style>

web/src/lib/components/Sidebar.svelte

@@ -1,6 +1,7 @@
 <script>
 	import { app, sidebar, projectName } from '$lib/stores.svelte.js';
 	import { api } from '$lib/api.js';
+	import { clearBadge } from '$lib/badge.js';
 	import { TASK, PROJECT, GROUP, NOTE, startDrag, carries, dragged, accept } from '$lib/dnd.js';
 	import { COLORS, colorVar } from '$lib/colors.js';
 	import { focusOnMount } from '$lib/focus.js';
@@ -31,6 +32,9 @@
 
 	async function signOut() {
 		await api.logout();
+		// Mærket på ikonet er den forriges ulæste. Det står i Dock'en, også når
+		// ingen er logget ind, så det skal væk sammen med resten af dem.
+		clearBadge();
 		// Empty the offline data cache before leaving: the service worker keeps the
 		// last-seen task and note lists so a network drop does not blank the app, and
 		// the next person to sign in on this browser must not find them.

web/src/lib/locales/da.js

@@ -77,6 +77,22 @@ export const da = {
 	'notes.sortUpdated': 'Senest rørt',
 	'notes.sortCreated': 'Oprettet',
 	'notes.sortTitle': 'Navn',
+	// AI'ens forslag. Ordene skal gøre det klart, at der bliver foreslået og ikke
+	// rettet: den, der siger ja, er den, der bestemmer.
+	'ai.tidyInbox': 'Ryd op i indbakken',
+	'ai.tidyTitle': 'Forslag til indbakken',
+	'ai.tidyHint':
+		'Sådan kunne linjerne have set ud, hvis de var skrevet færdig. Ret i dem, du vil rette i — der sker først noget, når du siger ja.',
+	'ai.findActions': 'Find opgaver i noten',
+	'ai.actionsTitle': 'Opgaver i noten',
+	'ai.actionsHint':
+		'Det, nogen har lovet eller er blevet bedt om i teksten. Citatet under hver linje er de ord, den kom fra.',
+	'ai.thinking': 'Læser …',
+	'ai.nothingToSuggest': 'Der er ikke noget at foreslå.',
+	'ai.accept': 'Tilføj',
+	'ai.skip': 'Nej tak',
+	'ai.applied': 'Gjort.',
+	'ai.allDone': 'Ikke mere at tage stilling til.',
 	'beacon.title': 'Tælling af installationer',
 	'beacon.hint': 'Én gang i døgnet melder denne installation, at den findes, så projektet kan se hvor mange der bruger det. Der sendes kun de to værdier herunder — et tilfældigt id og versionen — og intet andet: ingen IP bliver gemt, ingen navne, ingen adresser, intet om hvad du bruger det til. Slået til som udgangspunkt, og du kan slå den fra her.',
 	'beacon.send': 'Send en anonym daglig melding',
@@ -751,6 +767,17 @@ export const da = {
 		'Der er ingen mailserver sat op på denne server, så adressen herunder kan ikke modtage noget endnu. Sæt VERDANDE_SMTP_HOST og de øvrige SMTP-indstillinger, og få mailserveren til at aflevere post til todo+* videre til /inbound/mail.',
 	'int.yourAddress': 'Din adresse',
 	'int.newAddress': 'Ny adresse',
+	// Krogen ind i indbakken: en URL, et andet program kan skubbe en opgave til.
+	'int.hookToTask': 'Skub fra andre programmer',
+	'int.hookHint':
+		'En adresse, andre programmer kan sende en opgave til — en genvej på telefonen, et script, en tjeneste, der kan kalde en URL. Linjen læses som i feltet øverst i fladen, så “i morgen”, “p1” og “#Projekt” betyder det samme her.',
+	'int.yourHook': 'Din adresse',
+	'int.hookHow':
+		'Send en POST med teksten som krop — ren tekst, JSON med et {text}-felt, eller et formularfelt. Første linje bliver opgaven, resten står under den. Adressen er en nøgle: den, der har den, kan lægge opgaver i din indbakke og ikke andet.',
+	'int.hookExample': 'Sådan ser det ud',
+	'int.newHook': 'Ny adresse',
+	'int.newHookQuestion':
+		'Vil du have en ny adresse? Den gamle holder op med at virke med det samme, og alt, der bruger den, skal rettes.',
 	'int.caldav': 'CalDAV',
 	'int.caldavHint':
 		'Tovejs, i modsætning til feedet ovenfor: Apple Påmindelser og Thunderbird kan også skrive tilbage.',

web/src/lib/locales/en.js

@@ -74,6 +74,22 @@ export const en = {
 	'notes.sortUpdated': 'Last touched',
 	'notes.sortCreated': 'Created',
 	'notes.sortTitle': 'Name',
+	// The AI's suggestions. The words have to make it plain that this proposes
+	// rather than edits: whoever says yes is the one deciding.
+	'ai.tidyInbox': 'Tidy up the inbox',
+	'ai.tidyTitle': 'Suggestions for the inbox',
+	'ai.tidyHint':
+		'How the lines could have read if they had been finished. Edit the ones you want to edit — nothing happens until you say yes.',
+	'ai.findActions': 'Find tasks in the note',
+	'ai.actionsTitle': 'Tasks in the note',
+	'ai.actionsHint':
+		'What somebody promised or was asked to do in the text. The quote under each line is the words it came from.',
+	'ai.thinking': 'Reading …',
+	'ai.nothingToSuggest': 'There is nothing to suggest.',
+	'ai.accept': 'Add',
+	'ai.skip': 'No thanks',
+	'ai.applied': 'Done.',
+	'ai.allDone': 'Nothing left to decide on.',
 	'beacon.title': 'Counting installations',
 	'beacon.hint': 'Once a day this installation reports that it exists, so the project can see how many people run it. It sends only the two values below — a random id and the version — and nothing else: no IP is stored, no names, no addresses, nothing about what you use it for. On by default, and you can turn it off here.',
 	'beacon.send': 'Send an anonymous daily report',
@@ -748,6 +764,17 @@ export const en = {
 		'No mail server is configured on this server, so the address below cannot receive anything yet. Set VERDANDE_SMTP_HOST and the other SMTP settings, and have the mail server deliver post for todo+* to /inbound/mail.',
 	'int.yourAddress': 'Your address',
 	'int.newAddress': 'New address',
+	// The hook into the inbox: a URL another program can push a task to.
+	'int.hookToTask': 'Push from other programs',
+	'int.hookHint':
+		'An address other programs can send a task to — a shortcut on your phone, a script, any service that can call a URL. The line is read the way the box at the top of the app reads it, so “tomorrow”, “p1” and “#Project” mean the same here.',
+	'int.yourHook': 'Your address',
+	'int.hookHow':
+		'Send a POST with the text as the body — plain text, JSON with a {text} field, or a form field. The first line becomes the task and the rest sits underneath it. The address is a key: whoever has it can put tasks in your inbox, and nothing else.',
+	'int.hookExample': 'What it looks like',
+	'int.newHook': 'New address',
+	'int.newHookQuestion':
+		'Do you want a new address? The old one stops working immediately, and anything using it has to be changed.',
 	'int.caldav': 'CalDAV',
 	'int.caldavHint':
 		'Two-way, unlike the feed above: Apple Reminders and Thunderbird can write back as well.',

web/src/routes/+layout.svelte

@@ -10,6 +10,7 @@
 	import SignIn from '$lib/components/SignIn.svelte';
 	import TaskDetail from '$lib/components/TaskDetail.svelte';
 	import { t } from '$lib/i18n.svelte.js';
+	import { setBadge } from '$lib/badge.js';
 
 	let { children } = $props();
 
@@ -53,6 +54,13 @@
 		app.load();
 	});
 
+	// Tallet på appens ikon følger klokken. Ét sted, fordi der er ét tal: hentet,
+	// skubbet over websocket'en eller læst væk — mærket er det samme svar på alle
+	// tre, og en optælling pr. vej ville være tre, der kan blive uenige.
+	$effect(() => {
+		setBadge(app.unread);
+	});
+
 	/**
 	 * Global keys.
 	 *

web/src/routes/indstillinger/integrationer/+page.svelte

@@ -289,6 +289,9 @@
 
 	let feedURL = $state('');
 	let mailAddress = $state('');
+	// Krogen ind i indbakken: den URL, en genvej på telefonen eller et script kan
+	// skubbe en linje tekst til.
+	let hookURL = $state('');
 	/** Null until loaded, so the warning does not flash before the answer is in. */
 	let mailConfigured = $state(null);
 
@@ -301,6 +304,10 @@
 				mailConfigured = r.configured;
 			})
 			.catch(() => {});
+		api
+			.getHookURL()
+			.then((r) => (hookURL = r.url))
+			.catch(() => {});
 	});
 
 	async function rotateFeed() {
@@ -323,6 +330,15 @@
 		}
 	}
 
+	async function rotateHook() {
+		if (!confirm(t('int.newHookQuestion'))) return;
+		try {
+			hookURL = (await api.rotateHookURL()).url;
+		} catch (e) {
+			app.toast(humanMessage(e));
+		}
+	}
+
 	async function copy(text) {
 		try {
 			await navigator.clipboard.writeText(text);
@@ -674,6 +690,38 @@
 	</div>
 </section>
 
+<section class="panel">
+	<header>
+		<h2>{t('int.hookToTask')}</h2>
+		<p class="hint">
+			{t('int.hookHint')}
+		</p>
+	</header>
+
+	<div class="field">
+		<label for="hook">{t('int.yourHook')}</label>
+		<input id="hook" class="mono" value={hookURL} readonly />
+		<p class="hint">
+			{t('int.hookHow')}
+		</p>
+	</div>
+
+	<!-- Vist som den kommando, den er. Den, der skal sætte det op, skal kunne
+	     prøve det af ét sted, før de bygger genvejen på telefonen — og se, at
+	     kroppen bare er den linje, opgaven skal hedde. -->
+	<div class="field">
+		<label for="hookcurl">{t('int.hookExample')}</label>
+		<textarea id="hookcurl" class="mono" rows="3" readonly
+			>{`curl -X POST ${hookURL} \\\n  -H "Content-Type: text/plain" \\\n  -d "Ring til Anders i morgen p1 #Firma"`}</textarea
+		>
+	</div>
+
+	<div class="row">
+		<button class="secondary" onclick={() => copy(hookURL)}>{t('int.copy')}</button>
+		<button class="danger" onclick={rotateHook}>{t('int.newHook')}</button>
+	</div>
+</section>
+
 <section class="panel">
 	<header>
 		<h2>{t('int.caldav')}</h2>

web/src/routes/noter/+page.svelte

@@ -19,6 +19,7 @@
 	import { NOTE, startDrag } from '$lib/dnd.js';
 	import { colorVar } from '$lib/colors.js';
 	import NoteEditor from '$lib/components/NoteEditor.svelte';
+	import AISuggestions from '$lib/components/AISuggestions.svelte';
 
 	let notes = $state([]);
 
@@ -207,6 +208,9 @@
 	// Linket vises kun, når instansen ikke kan sende post. Så er det den eneste vej
 	// frem, og det skal kunne kopieres frem for at forsvinde.
 	let shareInviteLink = $state('');
+	// Opgaver, der ligger i notens tekst. Lukket, indtil nogen spørger: det koster
+	// et kald til en model, og de fleste noter er ikke referater.
+	let showActions = $state(false);
 	const ownsSelected = $derived(!!selected && selected.created_by === app.user?.id);
 
 	// Dem, et `@` kan betyde i den åbne note.
@@ -246,8 +250,9 @@
 
 	$effect(() => {
 		const id = selected?.id;
-		// Nulstil ved hvert skift, så den forrige notes folk ikke står et øjeblik
-		// under den nye.
+		// Nulstil ved hvert skift, så den forrige notes folk — og den forrige notes
+		// forslag — ikke står et øjeblik under den nye.
+		showActions = false;
 		shares = [];
 		shareCandidates = [];
 		shareFollows = [];
@@ -1086,6 +1091,16 @@
 				onsave={save}
 			/>
 
+			{#if showActions}
+				<AISuggestions
+					title={t('ai.actionsTitle')}
+					hint={t('ai.actionsHint')}
+					load={() => api.aiNoteActions(selected.id)}
+					apply={(row, line) => api.aiCreateFromNote(selected.id, line)}
+					onclose={() => (showActions = false)}
+				/>
+			{/if}
+
 			<footer>
 				<span class="hint">{saving ? t('notes.saving') : t('notes.saved')}</span>
 				{#if links.length}
@@ -1274,6 +1289,12 @@
 					{/if}
 
 					<button class="button" onclick={save}>{t('notes.save')}</button>
+					<!-- Det, nogen har lovet i et referat, står i teksten og ikke på
+					     listen. Knappen finder det frem som forslag; opgaverne bliver
+					     til noget, når man siger ja til dem. -->
+					<button class="button" onclick={() => (showActions = !showActions)}>
+						{t('ai.findActions')}
+					</button>
 					{#if ownsSelected}
 						<!-- Laid away, not thrown away: archive is the note leaving the list
 						     without leaving the account, and it reads "bring it back" once it

web/src/routes/projekt/[id]/+page.svelte

@@ -10,6 +10,7 @@
 	import TaskList from '$lib/components/TaskList.svelte';
 	import TaskRow from '$lib/components/TaskRow.svelte';
 	import QuickAdd from '$lib/components/QuickAdd.svelte';
+	import AISuggestions from '$lib/components/AISuggestions.svelte';
 	import BoardView from '$lib/components/BoardView.svelte';
 	import CalendarView from '$lib/components/CalendarView.svelte';
 	import { focusOnMount } from '$lib/focus.js';
@@ -31,6 +32,10 @@
 	let members = $state([]);
 	let showShare = $state(false);
 	let showLog = $state(false);
+	// Oprydningen i indbakken. Kun dér: det er den ene liste, der bliver fyldt med
+	// linjer, ingen nåede at skrive færdig, og derfor den ene, hvor det er værd at
+	// spørge en model om, hvordan de skulle have set ud.
+	let showTidy = $state(false);
 	let activity = $state([]);
 	let inviteEmail = $state('');
 	let inviteRole = $state('editor');
@@ -613,6 +618,18 @@
 							{completedView.shown ? t('view.hideDone') : t('view.showDone')}
 						</button>
 
+						{#if project.is_inbox}
+							<button
+								role="menuitem"
+								onclick={() => {
+									showTidy = !showTidy;
+									showMenu = false;
+								}}
+							>
+								{t('ai.tidyInbox')}
+							</button>
+						{/if}
+
 						{#if !project.is_inbox}
 							<button
 								role="menuitem"
@@ -665,6 +682,18 @@
 			</div>
 		</header>
 
+		{#if showTidy}
+			<!-- Forslag, ikke rettelser. Hver linje står i et felt, man kan skrive
+			     i, og sker først, når nogen siger ja til den. -->
+			<AISuggestions
+				title={t('ai.tidyTitle')}
+				hint={t('ai.tidyHint')}
+				load={() => api.aiTidyInbox()}
+				apply={(row, line) => api.aiApplyToTask(row.task_id, line)}
+				onclose={() => (showTidy = false)}
+			/>
+		{/if}
+
 		{#if showLog}
 			<div class="panel">
 				<ul class="log">

web/src/service-worker.js

@@ -145,6 +145,19 @@ self.addEventListener('push', (event) => {
 	}
 
 	const title = payload.title || 'verdande';
+	// Mærket på appens ikon — i Dock'en på en Mac, på proceslinjen på en pc.
+	//
+	// Sat her, fordi det her er det eneste, der kører, når appen ikke er åben: det
+	// er netop dér, et tal på ikonet er det, der siger, at der er noget nyt. Tallet
+	// kommer med beskeden frem for at blive talt op her; en service-worker husker
+	// ingenting mellem to opvågninger, så et mærke, den selv talte, ville kun kunne
+	// gå opad.
+	//
+	// Kan browseren ikke sætte mærker, sker der ingenting. Det er ikke en fejl at
+	// melde om: beskeden selv kom frem, og den er hovedsagen.
+	if (typeof payload.unread === 'number' && 'setAppBadge' in self.navigator) {
+		self.navigator.setAppBadge(payload.unread).catch(() => {});
+	}
 	event.waitUntil(
 		self.registration.showNotification(title, {
 			body: payload.body || '',