Create a Chat Inbox using Dataview

One dashboard note that surfaces active and completed Smart Chat codeblock threads across your vault.

Once threads are saved in the notes they serve, the next question becomes:

What delegated chat work is still open?

A Chat Inbox makes open threads visible so follow-up does not depend on memory alone.

It does not decide what is done for you.
Active and Done are user-owned tracking states.

What this solves

Use a Chat Inbox when:

• useful AI threads are attached to notes, but you forget which ones are still open
• project follow-up is spread across many notes
• you want one place to review active delegated work
• completed threads should remain searchable without crowding active work

The dashboard reads chat-active:: and chat-done:: fields saved by Smart Chat codeblocks.

The note remains the work item.
The thread is delegated work-state.
The deliverable is promoted only after review.

Build a Chat Inbox in 30 seconds

1. Create a note named Chat Inbox.
2. Paste the Dataview blocks below.
3. Put this note somewhere you actually open, such as a daily note, work dashboard, or project hub.

Waiting on active threads

```dataview
LIST map(
  reverse(sort(rows, (r) => r.impact)),
  (r) => r.impact + " " + r.file.link
)
WHERE chat-active
GROUP BY file.mday AS g
SORT g DESC
```

Completed threads

```dataview
LIST choice(typeof(chat-done)="string", 1, length(chat-done))
WHERE chat-done
SORT choice(typeof(chat-done)="string", 1, length(chat-done)) DESC
```

2-minute win

1. Install Dataview.
2. Create a Chat Inbox note.
3. Paste the two Dataview blocks.
4. Attach one thread using the Smart Chat codeblock.
5. Mark the thread active or done from the note it serves.

You know it worked when:

One dashboard note shows which chat threads are active or completed without hunting through browser tabs.

Active vs Done

Active and Done are user-owned tracking states.

Done does not mean Smart Chat objectively knows the work is complete.

Done means you reviewed the thread and decided the loop is closed for now.

Review before promoting output

A Chat Inbox helps you find delegated work.
It does not turn AI output into trusted note content automatically.

Use this review loop:

1. Open the active thread from the originating note.
2. Compare the output against the note's outcome and context.
3. Keep raw output in a review, draft, or workspace area until it earns trust.
4. Promote only the parts that match your intent.
5. Mark the thread done when the loop is closed for now.

The thread is not the deliverable.

The thread is the delegated work-state attached to the note.
The deliverable belongs in the note only after review.

Dashboard variants

Active threads by most recently edited note

Use this when recency matters more than impact.

```dataview
LIST WITHOUT ID file.link
WHERE chat-active
SORT file.mtime DESC
```

Completed threads by count

Use this when you want to see which notes have the most closed chat loops.

```dataview
LIST choice(typeof(chat-done)="string", 1, length(chat-done))
WHERE chat-done
SORT choice(typeof(chat-done)="string", 1, length(chat-done)) DESC
```

Show active and done totals

```dataviewjs
function count_field_value_instances(value) {
  if (value === null || value === undefined) return 0;
  return Array.isArray(value) ? value.length : 1;
}

const pages = dv.pages()
  .where(p => p["chat-active"] || p["chat-done"])
  .array();

const totals = pages.reduce((acc, page) => {
  acc.active_total += count_field_value_instances(page["chat-active"]);
  acc.done_total += count_field_value_instances(page["chat-done"]);
  return acc;
}, { active_total: 0, done_total: 0 });

dv.paragraph(`**Total chat-active instances:** ${totals.active_total}`);
dv.paragraph(`**Total chat-done instances:** ${totals.done_total}`);
dv.paragraph(`**Total tracked threads:** ${totals.active_total + totals.done_total}`);
```

Tip: To scope a dashboard to a folder, replace dv.pages() with dv.pages('"YourFolderName"').

Workflow playbook

Daily review

1. Open Chat Inbox.
2. Open the highest-impact active thread.
3. Review the response against the originating note.
4. Promote only useful learning.
5. Mark the thread done or keep it active with a clearer next action.

Project review

1. Scope the Dataview query to a project folder.
2. Review active threads in that project.
3. Close threads that have been handled.
4. Update the project note with the next action or deliverable.

Cleanup

1. Find notes with many done threads.
2. Open the source note.
3. Confirm whether the thread links still matter.
4. Keep useful history and remove only what you intentionally no longer need.

Mobile vs desktop

On mobile, treat Smart Chat codeblocks as a lightweight thread index attached to the note.
The dashboard can still surface chat-active:: and chat-done:: state because those fields live in Markdown.

FAQ

Is this the same as Smart Chat Thread Manager?

No.

A Chat Inbox reads note-attached chat-active:: and chat-done:: state across your vault.

Smart Chat Thread Manager manages Smart Chat API Extension thread records directly.

Use both when you want both views:

• Chat Inbox: what delegated work is active or done in notes
• Thread Manager: what Smart Chat API Extension threads exist and need naming, search, opening, or cleanup

Does Done mean the AI finished the work correctly?

No.

Done is a user-owned tracking state. It means you reviewed the thread and closed the loop for now.

Does this work without Pro?

The Dataview dashboard works with note-attached Smart Chat codeblock fields.

Smart Chat API Extension thread management is a separate Pro workflow.

Should I delete done thread links?

Not automatically.

Done thread links can be useful history. Delete or remove them only when you have reviewed the note and decided the reference no longer helps.

Related pages

• Smart Chat codeblocks
• Getting Started with Smart Chat
• Manage Smart Chat API Extension threads from one dashboard
• Use local and API models in Smart Chat
• Smart Loop
• Dataview plugin