feat(query): add overview() for project-aware session/memory discovery

Resolves current project from cwd, lists all known projects with session
  and memory counts, and returns the current project's recent sessions and
  memories in one call. Enables the agent to orient itself at the start of
  a retrieval without multiple exploratory queries.

references/query-patterns.md

@@ -4,6 +4,37 @@ These are copyable CodeAct patterns for `runtime.mjs --query` scripts, plus one
 `--remember` registration pattern. They are not new APIs. Adapt them to the
 user's scope and return compact evidence.
 
+## Orient Before Retrieval
+
+Use `overview()` when the current project or available scopes are unclear. Treat
+the result as a map, not evidence; follow up with `memories()`, `search()`,
+helpers, or `sql()` for facts.
+
+```js
+const map = overview({ limit: 6 });
+return {
+  current: map.current,
+  current_project: map.current_project && {
+    project: map.current_project.project,
+    session_total: map.current_project.session_total,
+    sessions: map.current_project.sessions.map(s => ({
+      id: s.id,
+      title: s.title,
+      branch: s.git_branch,
+      ended_at: s.ended_at,
+    })),
+    memory_total: map.current_project.memory_total,
+    memories: map.current_project.memories.map(m => ({
+      id: m.id,
+      path: m.path,
+      summary: m.summary?.slice(0, 240),
+    })),
+  },
+  projects: map.projects.slice(0, 8),
+  totals: map.totals,
+};
+```
+
 ## Bounded Search To Context
 
 Use `search()` to locate candidates, then expand only the strongest hits.

references/retrieval-semantics.md

@@ -11,10 +11,16 @@ Classify the user's request before choosing tools.
 
 | User signal | Locator mode | Start with | Avoid first |
 |-------------|--------------|------------|-------------|
+| unclear project/session landscape | orientation | `overview()` | treating overview rows as evidence |
 | project name/path, session, cwd, file, time range | scope | `sessions()`, exact SQL on `project_path`, `sessionId`, `fileHistory()` | broad FTS |
 | workflow, subagent, tool call, summary, edit | artifact | `workflows()`, `subagents()`, `summaries()`, `tool_calls`, `tool_results` | all-session search |
 | concept, conclusion, design history, vague memory | semantic | `memories({ query })`, `search()`, summaries, bounded facet sweep | session dumps |
 
+`overview()` is a navigation map: current cwd/project if knowable, global
+project counts, and recent current-project session/memory entry points. Use it
+when scope is unclear, then query the memory or raw session layer for evidence.
+It does not guess the current session.
+
 One-shot retrieval is not all-shot retrieval. A query script may perform
 multiple steps, but the first locator should be the narrowest semantic fit. If a
 scope locator finds the relevant project/session/file, do not also run broad FTS
@@ -94,6 +100,15 @@ For semantic questions, build a task-local evidence view:
 Then synthesize the conclusion in the final answer. Do not pretend the raw
 evidence view is itself a stored Obelisk entity.
 
+After synthesis, check whether the conclusion should become a memory. Offer to
+write one when the result is durable, likely to help future sessions, and not
+already covered by `prior_memories`. Good candidates include design decisions,
+project conventions, abandoned alternatives, repeated failure causes, workflow
+patterns, and conclusions synthesized across multiple raw evidence points. Do
+not propose memory for one-off lookups, uncertain findings, or duplicate
+coverage. The offer is only a proposal: write the markdown file and run
+`--remember` only after user approval.
+
 ## Text Search Semantics
 
 `search(text)` passes text to SQLite FTS5 `MATCH`.

references/schema.md

@@ -416,6 +416,85 @@ const last5 = recent(5);
 return last5.map(s => ({ title: s.title, project: s.project_path, ended: s.ended_at }));
 ```
 
+#### `overview(opts?)`
+
+Compact orientation map for choosing the next retrieval scope. It is not an
+evidence helper: it does not return snippets, full messages, or markdown file
+contents. Passing a string is treated as `project`, and passing a number is
+treated as the current-project session `limit`.
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `opts.project` | `string` | Project slug or SQL `LIKE` pattern to use as the current project scope |
+| `opts.limit` | `number` | Max recent sessions in `current_project.sessions` (default 8) |
+| `opts.projectLimit` | `number` | Max rows in the global `projects` map (default 20) |
+| `opts.memoryLimit` | `number` | Max memory records in `current_project.memories` (default 100) |
+
+If `opts.project` is absent, `overview()` tries to identify the current project
+from `process.cwd()` against `sessions.project_path`, then from exact
+`messages.cwd` matches. It does not guess the current session.
+
+**Returns:**
+
+```js
+{
+  current: {
+    cwd,
+    project: {
+      project,
+      project_path,
+      source: 'opts' | 'cwd_project_path' | 'cwd_messages',
+      confidence: 'exact' | 'inferred' | 'unknown'
+    } | null
+  },
+  current_project: {
+    project,
+    project_path,
+    session_total,
+    sessions: [
+      { id, title, project, project_path, started_at, ended_at, git_branch, message_count }
+    ],
+    memory_total,
+    memories: [
+      { id, path, summary, session_id, project, created_at }
+    ]
+  } | null,
+  projects: [
+    {
+      project,
+      project_path,
+      session_count,
+      memory_count,
+      last_session_at,
+      last_memory_at,
+      recent_branches
+    }
+  ],
+  totals: { projects, sessions, memories }
+}
+```
+
+Use `current_project.sessions` as recent entry points only. `session_total` and
+`memory_total` tell you whether the returned arrays are complete enough for the
+task. Confirm facts with `memories()`, `search()`, other helpers, or `sql()`.
+
+```js
+const map = overview({ limit: 5 });
+return {
+  current: map.current,
+  sessions: map.current_project?.sessions.map(s => ({
+    id: s.id,
+    title: s.title,
+    ended_at: s.ended_at,
+  })),
+  memories: map.current_project?.memories.map(m => ({
+    id: m.id,
+    path: m.path,
+    summary: m.summary,
+  })),
+};
+```
+
 #### `sessions(opts?)`
 
 Query sessions with filters. For backward compatibility, passing a number is treated as `limit`.