@lanes-sh/link 0.4.0 → 0.5.0

package/src/cli/commands/owner/tasks.ts

@@ -0,0 +1,194 @@
+import { ConfigError } from '#profile';
+import { scopeNamespace } from '#dispatch';
+import { scopeBlobStore, type BlobStore } from '#stores/blobs';
+import { ACTIVE_STATUSES, TASK_STATUSES, taskStorage, type TaskStatus } from '#providers/owner.ts';
+import { heading, ok, print, style, table } from '../../output.ts';
+import type { Runtime } from '../../runtime.ts';
+import {
+  agreed,
+  optionalStdin,
+  ownerConnection,
+  required,
+  withRuntime,
+  type OwnerFlags,
+} from './shared.ts';
+
+/** `lanes link tasks` — what the owner has to do. */
+
+export async function tasksList(flags: OwnerFlags): Promise<void> {
+  await withRuntime(flags, async (runtime) => {
+    const store = tasksStore(runtime, flags);
+
+    // The same default the `tasks.list` capability applies, and for the same
+    // reason: the question is what is outstanding, and a list that grows forever
+    // is one nobody reads. `--status all` is the escape hatch.
+    const wanted = statusFilter(flags.status);
+    const tasks = (await taskStorage.all(store)).filter(
+      (task) =>
+        (wanted === null || wanted.has(task.status)) && (!flags.tag || task.tags.includes(flags.tag)),
+    );
+
+    heading(`Tasks (${tasks.length}${wanted === null ? '' : ' outstanding'})`);
+    if (tasks.length === 0) {
+      print(style.dim('  none — add one with: lanes link tasks add <title>'));
+      return;
+    }
+
+    table(
+      tasks.map((task) => [
+        `  ${task.id}`,
+        task.status,
+        task.title,
+        task.due ? style.dim(`due ${task.due}`) : '',
+        task.tags.length > 0 ? style.dim(task.tags.join(', ')) : '',
+      ]),
+    );
+  });
+}
+
+export async function tasksGet(id: string | undefined, flags: OwnerFlags): Promise<void> {
+  const taskId = required(id, 'lanes link tasks get <id>');
+
+  await withRuntime(flags, async (runtime) => {
+    const task = await taskStorage.read(tasksStore(runtime, flags), taskId);
+    if (!task) throw new ConfigError(`No task "${taskId}" in this profile.`);
+
+    print('');
+    print(`  ${style.bold(task.title)}`);
+    print(style.dim(`  ${task.status}${task.due ? `  due ${task.due}` : ''}`));
+    if (task.tags.length > 0) print(style.dim(`  ${task.tags.join(', ')}`));
+    if (task.body.length > 0) {
+      print('');
+      print(task.body);
+    }
+  });
+}
+
+/**
+ * `lanes link tasks add <title>` — the title on argv, notes optional on stdin.
+ *
+ * Unlike `memory write`, the title is the argument and the body is optional: a
+ * task is usually one line, and demanding a heredoc to write "chase the invoice"
+ * would make the common case the awkward one. So `optionalStdin` rather than
+ * `readStdin` — see its docstring for what refusing an empty pipe here broke.
+ */
+export async function tasksAdd(title: string | undefined, flags: OwnerFlags): Promise<void> {
+  const given = required(title, 'lanes link tasks add <title>   (notes on stdin, optional)');
+  const notes = await optionalStdin();
+
+  await withRuntime(flags, async (runtime) => {
+    const store = tasksStore(runtime, flags);
+    const id = taskStorage.slugify(given);
+    const existing = await taskStorage.read(store, id);
+    const now = new Date().toISOString();
+
+    await taskStorage.write(store, {
+      id,
+      title: given,
+      status: assertStatus(flags.status) ?? 'open',
+      tags: flags.tag ? [flags.tag] : (existing?.tags ?? []),
+      ...(flags.due ? { due: flags.due } : {}),
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      body: notes,
+    });
+
+    print(ok(`${existing ? 'replaced' : 'added'} task ${style.bold(id)}`));
+  });
+}
+
+/**
+ * `lanes link tasks update <id> --status done`.
+ *
+ * Omitted flags leave their fields alone, which is what makes this the way to
+ * close a task rather than delete it: the record of having done it is the useful
+ * part, and `--status done` keeps everything else.
+ */
+export async function tasksUpdate(id: string | undefined, flags: OwnerFlags): Promise<void> {
+  const taskId = required(id, 'lanes link tasks update <id> --status <status>');
+
+  await withRuntime(flags, async (runtime) => {
+    const store = tasksStore(runtime, flags);
+    const existing = await taskStorage.read(store, taskId);
+    if (!existing) throw new ConfigError(`No task "${taskId}" in this profile.`);
+
+    const status = assertStatus(flags.status);
+    if (!status && !flags.title && !flags.due && !flags.tag) {
+      throw new ConfigError(
+        `Nothing to change. Pass --status, --title, --due or --tag.\n` +
+          `  statuses: ${TASK_STATUSES.join(', ')}`,
+      );
+    }
+
+    // `due` is taken off the existing record rather than spread and overwritten,
+    // because spreading cannot remove a key — the same trap the provider's
+    // `update` documents.
+    const { due: previous, ...rest } = existing;
+    const due = flags.due === '' ? undefined : (flags.due ?? previous);
+
+    await taskStorage.write(store, {
+      ...rest,
+      title: flags.title ?? existing.title,
+      status: status ?? existing.status,
+      tags: flags.tag ? [flags.tag] : existing.tags,
+      ...(due ? { due } : {}),
+      updatedAt: new Date().toISOString(),
+    });
+
+    print(ok(`updated task ${style.bold(taskId)} — now ${status ?? existing.status}`));
+  });
+}
+
+export async function tasksRemove(id: string | undefined, flags: OwnerFlags): Promise<void> {
+  const taskId = required(id, 'lanes link tasks remove <id>');
+
+  await withRuntime(flags, async (runtime) => {
+    const store = tasksStore(runtime, flags);
+    const task = await taskStorage.read(store, taskId);
+    if (!task) throw new ConfigError(`No task "${taskId}" in this profile.`);
+
+    print(`  ${style.bold(task.id)}  ${task.status}  ${task.title}`);
+    print(
+      style.dim('  deleting loses the record that it happened — "update --status done" keeps it'),
+    );
+    if (!(await agreed(flags, 'Delete this task?'))) return;
+
+    await store.delete(taskStorage.key(taskId));
+    print(ok(`deleted task ${style.bold(taskId)}`));
+  });
+}
+
+/**
+ * `--status` as a filter: a named one, `all`, or the outstanding set by default.
+ *
+ * `null` means every status. Returning a set rather than a predicate so the
+ * heading can say whether it narrowed.
+ */
+function statusFilter(raw: string | undefined): Set<TaskStatus> | null {
+  if (raw === 'all') return null;
+  if (raw === undefined) return new Set(ACTIVE_STATUSES);
+  return new Set([assertStatus(raw)!]);
+}
+
+function assertStatus(raw: string | undefined): TaskStatus | undefined {
+  if (raw === undefined) return undefined;
+  if (!(TASK_STATUSES as readonly string[]).includes(raw)) {
+    throw new ConfigError(
+      `Unknown status "${raw}". One of: ${TASK_STATUSES.join(', ')}` +
+        '\n  (or "all", when filtering a listing)',
+    );
+  }
+  return raw as TaskStatus;
+}
+
+/**
+ * The blob namespace core would scope this provider to.
+ *
+ * Built from `scopeNamespace` and `scopeBlobStore` — the same two functions
+ * `buildProviderContext` uses — rather than from a path spelled out again, so the
+ * CLI cannot address a different directory from the provider.
+ */
+export function tasksStore(runtime: Runtime, flags: OwnerFlags): BlobStore {
+  const connection = ownerConnection(runtime.config, 'tasks', flags);
+  return scopeBlobStore(runtime.storage, scopeNamespace('tasks', connection));
+}

package/src/cli/commands/owner.ts

@@ -1,5 +1,6 @@
 /**
- * `lanes link memory`, `lanes link skills`, `lanes link vault` — the owner layer's control plane.
+ * `lanes link memory`, `tasks`, `assets`, `skills`, `vault` — the owner layer's
+ * control plane.
  *
  * The layer shipped in M4 with no CLI at all, so the two stores holding the
  * owner's *own* data were reachable only by an agent, and the one thing that
@@ -20,9 +21,9 @@
  * both sides now: from here because this is the owner's control plane, and over
  * MCP because ADR-014 §1 decided a policy-gated grant beats a missing path.
  *
- * One noun per file — `memory.ts`, `skills.ts`, `vault.ts` — over the shape all
- * three share in `shared.ts`: the flag type, the open-announce-act-close
- * wrapper, connection resolution, and the two prompts.
+ * One noun per file — `memory.ts`, `tasks.ts`, `assets.ts`, `skills.ts`,
+ * `vault.ts` — over the shape they all share in `shared.ts`: the flag type, the
+ * open-announce-act-close wrapper, connection resolution, and the two prompts.
  */
 
 export {
@@ -33,6 +34,10 @@ export {
   memoryWrite,
 } from './owner/memory.ts';
 
+export { tasksAdd, tasksGet, tasksList, tasksRemove, tasksUpdate } from './owner/tasks.ts';
+
+export { assetsAdd, assetsGet, assetsList, assetsRemove } from './owner/assets.ts';
+
 export { skillsAdd, skillsList, skillsRemove, skillsShow } from './owner/skills.ts';
 
 export {

package/src/cli/config-edit.ts

@@ -264,13 +264,27 @@ oauth_apps: {}
 # reports — an address, a workspace — so this list says whose data is reachable
 # without having to look anything up.
 #
-# "setup" holds no account. It lets an agent see what is connected here and what
-# connecting something else would take, so it can tell you the command to run
-# rather than guess at one. It is read-only: nothing it offers writes config,
-# stores a credential, signs in, or changes what is permitted — those stay in
-# this CLI (ADR-007, ADR-019). Delete this entry and the allow line below to
-# remove it entirely.
+# The six below hold no account, and that is why they are here already: they
+# reach your own material rather than anybody's API, so there was never anything
+# for a connect step to authorise (ADR-050). What each one is:
+#
+#   memory   what you want remembered between sessions
+#   tasks    what you have to do, each with a status
+#   assets   files you want kept, by name
+#   skills   procedures you have written, handed to an agent as instructions
+#   vault    passwords and API keys, released one at a time
+#   setup    what is connected here, and what connecting more would take
+#
+# Nothing is stored in any of them until you or an agent puts something there,
+# and none of them can read an account. To switch one off, deny it below —
+# deleting the entry no longer works, because the next connect or deploy puts it
+# back.
 connections:
+  - { id: main, provider: memory, account: Memory }
+  - { id: main, provider: tasks, account: Tasks }
+  - { id: main, provider: assets, account: Assets }
+  - { id: main, provider: skills, account: Skills }
+  - { id: main, provider: vault, account: Vault }
   - { id: main, provider: setup, account: Setup }
 
 # Only what is listed here is reachable, and an empty policy grants nothing.
@@ -284,8 +298,20 @@ connections:
 #   allow: ['*']                  everything, which is what connect writes
 #   allow: [notion.*, gmail.*]    two providers
 #   deny:  [gmail.send_message]   a deny always beats an allow
+#
+# The rules below grant each of the six its whole namespace, writes included —
+# the same thing "connect memory" wrote when it was a command you had to run.
+# Narrowing is one line, and these are the three worth knowing:
+#
+#   deny: [memory.write]          memory becomes read-only
+#   deny: [skills.manage.*]       skills can be invoked but not authored
+#   deny: [vault.put, vault.remove]   nothing new can be stored
+#
+# A vault read is not granted by "vault.*" alone: each stored item is its own
+# "vault.get.<id>" capability and only appears after a restart, so a write can
+# never hand itself a read (ADR-012).
 policy:
-  allow: [setup.*]
+  allow: [memory.*, tasks.*, assets.*, skills.*, vault.*, setup.*]
   deny: []
 `;
 }

package/src/cli/config-repair.ts

@@ -1,4 +1,6 @@
-import type { ConfigDocument } from './config-edit.ts';
+import { listProfiles } from '#profile';
+import { ConfigDocument } from './config-edit.ts';
+import { ok, print, style, warn } from './output.ts';
 
 /**
  * Giving a profile a reserved provider it is missing, without undoing a choice.
@@ -9,22 +11,49 @@ import type { ConfigDocument } from './config-edit.ts';
  * was already there: that file knows how to *edit* YAML safely, and this one
  * knows what a reserved provider needs to be reachable at all.
  *
- * Two providers hold no account and are therefore invisible without a
- * connection row nobody would think to write: `setup`, which describes what is
- * connected, and `identity`, which says who the owner is. Both are repaired the
+ * The owner layer holds no account and is therefore invisible without a
+ * connection row nobody would think to write. Every one of them is repaired the
  * same way and the rules below are subtle enough that a second copy would drift
  * — which is the whole reason this is one function taking a provider id rather
- * than two that look alike.
+ * than several that look alike.
  */
 
 /** The reserved provider ids that hold no account, and the label each row carries. */
 const RESERVED_SURFACES = {
+  memory: 'Memory',
+  tasks: 'Tasks',
+  assets: 'Assets',
+  skills: 'Skills',
+  vault: 'Vault',
   setup: 'Setup',
   identity: 'Identity',
 } as const;
 
 type ReservedSurface = keyof typeof RESERVED_SURFACES;
 
+/**
+ * The ones a profile gets whether it asked or not.
+ *
+ * `identity` is the exception and stays off this list, for the reason
+ * `ensureIdentityConnection` gives: a profile with no identity block has nothing
+ * for the surface to report, so registering a tool that answers "nothing
+ * declared" would spend instructions budget to say so. Everything else here
+ * reaches the owner's own material and is empty until they put something in it,
+ * which is ADR-050's whole argument — so a profile written before those existed
+ * gets them on the next command rather than needing five of its own.
+ *
+ * Ordered as `RESERVED_PROVIDER_IDS` is, so a repair reports in the order the
+ * template writes and a diff between the two reads as a diff.
+ */
+export const DEFAULT_SURFACES: readonly ReservedSurface[] = [
+  'memory',
+  'tasks',
+  'assets',
+  'skills',
+  'vault',
+  'setup',
+];
+
 /**
  * What a repair did, split by what a caller does with each half.
  *
@@ -162,14 +191,28 @@ function patternsIn(rules: unknown, now = Date.now()): string[] {
 }
 
 /**
- * The `setup` surface, which every profile is expected to have.
+ * The owner layer, which every profile is expected to have.
+ *
+ * Was `ensureSetupConnection`, and grew rather than gained siblings: the callers
+ * are the same three, and what changed is how many surfaces "a profile should be
+ * able to reach its own material" covers. Repairs are accumulated so a caller
+ * reports one list — five separate calls would print five near-identical blocks
+ * on the one upgrade where any of them fire.
  *
- * A named wrapper rather than a call site passing `'setup'`, because three
- * callers say it and reading `ensureReservedConnection(document, 'setup')` at
- * each of them says less than the name did.
+ * Each surface is still decided independently, so a profile that denied exactly
+ * one of them keeps that decision while the rest are repaired.
  */
-export function ensureSetupConnection(document: ConfigDocument): SurfaceRepair {
-  return ensureReservedConnection(document, 'setup');
+export function ensureOwnerLayer(document: ConfigDocument): SurfaceRepair {
+  const changes: string[] = [];
+  const granted: string[] = [];
+
+  for (const provider of DEFAULT_SURFACES) {
+    const repair = ensureReservedConnection(document, provider);
+    changes.push(...repair.changes);
+    granted.push(...repair.granted);
+  }
+
+  return { changes, granted };
 }
 
 /**
@@ -184,3 +227,64 @@ export function ensureSetupConnection(document: ConfigDocument): SurfaceRepair {
 export function ensureIdentityConnection(document: ConfigDocument): SurfaceRepair {
   return ensureReservedConnection(document, 'identity');
 }
+
+/**
+ * Apply that repair across a workspace, saving and reporting what changed.
+ *
+ * Here rather than in `#deployments`, where it was, because `start` needs it as
+ * much as `deploy` does — more, in fact: `start` is the one command an existing
+ * install runs without being asked to, so it is the path by which a profile
+ * written before ADR-050 gets the layer at all. Two copies of a function that
+ * widens a policy is not a thing to have.
+ *
+ * **The caller scopes it**, and for `deploy` that is exactly the set being
+ * uploaded: a profile it sends is a profile the endpoint will serve, so
+ * repairing a narrower set would leave a served profile without the surfaces.
+ * Note what a `--profile` flag does not mean — it is the flag alone, so a
+ * profile resolved from the environment leaves it undefined and that reads as
+ * the whole workspace.
+ *
+ * *Which files are profiles* comes from `listProfiles`, never from an allowlist
+ * of what is safe to copy: that would happily hand over a committed
+ * `personal.example.yaml` or a nested `profiles/archive/old.yaml`, and this
+ * opens and validates what it is given — which once turned a template into a
+ * `ConfigError` aborting a deploy after provisioning had made cloud resources.
+ *
+ * A profile that cannot be read is warned about rather than fatal: the repair is
+ * a courtesy on the way past, and the caller's real work should still happen.
+ * Not silent, though — nothing else widens a policy without being asked.
+ *
+ * CLI-side by construction, like everything else in this file: a deployed
+ * revision holds `objectViewer` on `profiles/` (ADR-023) and could not write
+ * this even if the code let it.
+ */
+export async function repairOwnerLayer(
+  workspaceRoot: string,
+  profiles: readonly string[] | undefined,
+): Promise<void> {
+  const wanted = profiles === undefined ? undefined : new Set(profiles);
+
+  for (const name of await listProfiles(workspaceRoot)) {
+    if (wanted !== undefined && !wanted.has(name)) continue;
+
+    try {
+      const document = await ConfigDocument.open(workspaceRoot, name);
+      const repair = ensureOwnerLayer(document);
+      if (!repaired(repair)) continue;
+
+      await document.save();
+
+      print(ok(`gave ${style.bold(name)} its own owner layer`));
+      for (const change of repairLines(repair)) print(`      ${style.dim(change)}`);
+      print(
+        `      ${style.dim('memory, tasks, assets, skills, vault and setup — your own material, no account behind any of them')}`,
+      );
+    } catch (error) {
+      print(
+        warn(
+          `could not give ${name} its owner layer: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`,
+        ),
+      );
+    }
+  }
+}

package/src/cli/dispatch-owner.ts

@@ -1,4 +1,8 @@
 import {
+  assetsAdd,
+  assetsGet,
+  assetsList,
+  assetsRemove,
   memoryForget,
   memoryGet,
   memoryList,
@@ -11,18 +15,23 @@ import {
   vaultKeyGenerate,
   vaultList,
   vaultRemove,
+  tasksAdd,
+  tasksGet,
+  tasksList,
+  tasksRemove,
+  tasksUpdate,
   vaultSet,
   type OwnerFlags,
 } from './commands/owner.ts';
 
 /**
- * The three commands over the owner's own data: memory, skills, and the vault.
+ * The commands over the owner's own data: memory, tasks, assets, skills, vault.
  *
  * Split out of `main.ts` for the reason the budget in `src/architecture.test.ts`
- * exists to find, rather than to satisfy a line count. These three are one
- * subject — what the owner put here themselves, as against what a provider
- * holds on their behalf — they already live together in `commands/owner/`, and
- * they are the only commands in the grammar sharing a flag shape of their own.
+ * exists to find, rather than to satisfy a line count. These are one subject —
+ * what the owner put here themselves, as against what a provider holds on their
+ * behalf — they already live together in `commands/owner/`, and they are the
+ * only commands in the grammar sharing a flag shape of their own.
  *
  * `main.ts` keeps the grammar. This keeps one branch of it.
  */
@@ -49,6 +58,38 @@ export function dispatchOwner(
           throw new Error(`Unknown: ${program} memory ${second}`);
       }
 
+    case 'tasks':
+      switch (second) {
+        case 'list':
+        case undefined:
+          return tasksList(owner);
+        case 'get':
+          return tasksGet(rest[0], owner);
+        case 'add':
+          return tasksAdd(rest[0], owner);
+        case 'update':
+          return tasksUpdate(rest[0], owner);
+        case 'remove':
+          return tasksRemove(rest[0], owner);
+        default:
+          throw new Error(`Unknown: ${program} tasks ${second}`);
+      }
+
+    case 'assets':
+      switch (second) {
+        case 'list':
+        case undefined:
+          return assetsList(owner);
+        case 'get':
+          return assetsGet(rest[0], owner);
+        case 'add':
+          return assetsAdd(rest[0], owner);
+        case 'remove':
+          return assetsRemove(rest[0], owner);
+        default:
+          throw new Error(`Unknown: ${program} assets ${second}`);
+      }
+
     case 'skills':
       switch (second) {
         case 'list':
@@ -85,9 +126,9 @@ export function dispatchOwner(
       }
 
     default:
-      // Unreachable: `main.ts` narrows to the three above before calling. Kept
-      // so that adding a fourth case there and forgetting it here is a thrown
-      // error rather than a command that silently does nothing.
+      // Unreachable: `main.ts` narrows to the nouns above before calling. Kept
+      // so that adding one there and forgetting it here is a thrown error rather
+      // than a command that silently does nothing.
       throw new Error(`Unknown: ${program} ${first}`);
   }
 }

package/src/cli/lanes.ts

@@ -18,7 +18,7 @@ import { version } from './version.ts';
  */
 
 const AREAS: Record<string, string> = {
-  link: 'a self-hostable MCP gateway for all your connections, memory, skills, and secrets',
+  link: 'a self-hostable MCP gateway for all your connections, memory, tasks, files, and secrets',
 };
 
 function areasUsage(): string {

package/src/cli/main.ts

@@ -1,5 +1,6 @@
 import { connect } from './commands/connect/index.ts';
 import { connectCustom } from './commands/connect/custom/index.ts';
+import { disconnect, relabel } from './commands/connection.ts';
 import {
   attachFile,
   auditTail,
@@ -246,17 +247,20 @@ export async function run(argv: readonly string[]): Promise<void> {
       if (second !== 'show' && second !== undefined) throw new Error(`Unknown: ${PROGRAM} config ${second}`);
       return configShow(global);
 
-    // memory, skills and vault — one subject, dispatched together.
+    // The owner's own data — one subject, dispatched together.
     // `vault key generate` is synchronous, so this returns the result rather
     // than testing it for truthiness.
     case 'memory':
+    case 'tasks':
+    case 'assets':
     case 'skills':
     case 'vault':
       return dispatchOwner(first, second, rest, owner, PROGRAM);
 
     // Beside `memory` and `skills` because it is the question they raise next:
     // those two say what is stored, and this says where it is kept. Not one of
-    // them, though — it takes its own flags rather than the owner set.
+    // them, though — it takes its own flags rather than the owner set, and it
+    // moves those two only (ADR-041), not tasks or assets.
     case 'knowledge':
       switch (second) {
         case 'show':
@@ -321,10 +325,29 @@ export async function run(argv: readonly string[]): Promise<void> {
           return mcpStdio({ ...global, ...(flags['only'] === true ? { only: true } : {}) });
         case 'list':
         case undefined:
-          return mcpList({ name: text(flags, 'name'), scope: text(flags, 'scope') });
+          return mcpList({
+            name: text(flags, 'name'),
+            scope: text(flags, 'scope'),
+            json: flags['json'] === true,
+          });
         default:
           throw new Error(`Unknown: ${PROGRAM} mcp ${second}`);
       }
+    case 'disconnect':
+      return disconnect(second, {
+        ...global,
+        yes: flags['yes'] === true,
+        keepCredential: flags['keep-credential'] === true,
+        json: flags['json'] === true,
+      });
+    // The new label is joined rather than taken as `rest[0]`, so an unquoted
+    // multi-word name works: `relabel gmail.main Work Mail` is what someone
+    // types before they think about quoting, and refusing it teaches nothing.
+    case 'relabel':
+      return relabel(second, rest.length > 0 ? rest.join(' ') : undefined, {
+        ...global,
+        json: flags['json'] === true,
+      });
     case 'start':
       return start({
         ...global,

package/src/cli/provider-marks.ts

@@ -41,5 +41,5 @@ export const PROVIDER_MARKS: Readonly<Record<string, string>> = {
   linear: 'M2.886 4.18A11.982 11.982 0 0 1 11.99 0C18.624 0 24 5.376 24 12.009c0 3.64-1.62 6.903-4.18 9.105L2.887 4.18ZM1.817 5.626l16.556 16.556c-.524.33-1.075.62-1.65.866L.951 7.277c.247-.575.537-1.126.866-1.65ZM.322 9.163l14.515 14.515c-.71.172-1.443.282-2.195.322L0 11.358a12 12 0 0 1 .322-2.195Zm-.17 4.862 9.823 9.824a12.02 12.02 0 0 1-9.824-9.824Z',
   notion: 'M4.459 4.208c.746.606 1.026.56 2.428.466l13.215-.793c.28 0 .047-.28-.046-.326L17.86 1.968c-.42-.326-.981-.7-2.055-.607L3.01 2.295c-.466.046-.56.28-.374.466zm.793 3.08v13.904c0 .747.373 1.027 1.214.98l14.523-.84c.841-.046.935-.56.935-1.167V6.354c0-.606-.233-.933-.748-.887l-15.177.887c-.56.047-.747.327-.747.933zm14.337.745c.093.42 0 .84-.42.888l-.7.14v10.264c-.608.327-1.168.514-1.635.514-.748 0-.935-.234-1.495-.933l-4.577-7.186v6.952L12.21 19s0 .84-1.168.84l-3.222.186c-.093-.186 0-.653.327-.746l.84-.233V9.854L7.822 9.76c-.094-.42.14-1.026.793-1.073l3.456-.233 4.764 7.279v-6.44l-1.215-.139c-.093-.514.28-.887.747-.933zM1.936 1.035l13.31-.98c1.634-.14 2.055-.047 3.082.7l4.249 2.986c.7.513.934.653.934 1.213v16.378c0 1.026-.373 1.634-1.68 1.726l-15.458.934c-.98.047-1.448-.093-1.962-.747l-3.129-4.06c-.56-.747-.793-1.306-.793-1.96V2.667c0-.839.374-1.54 1.447-1.632z',
   sheets: 'M11.318 12.545H7.91v-1.909h3.41v1.91zM14.728 0v6h6l-6-6zm1.363 10.636h-3.41v1.91h3.41v-1.91zm0 3.273h-3.41v1.91h3.41v-1.91zM20.727 6.5v15.864c0 .904-.732 1.636-1.636 1.636H4.909a1.636 1.636 0 0 1-1.636-1.636V1.636C3.273.732 4.005 0 4.909 0h9.318v6.5h6.5zm-3.273 2.773H6.545v7.909h10.91v-7.91zm-6.136 4.636H7.91v1.91h3.41v-1.91z',
-  tasks: 'M11.383.617C5.097.617 0 5.714 0 12c0 6.286 5.097 11.383 11.383 11.383 6.286 0 11.38-5.097 11.38-11.383a11.34 11.34 0 0 0-.878-4.389l-3.203 3.203c.062.387.1.782.1 1.186a7.398 7.398 0 1 1-7.4-7.398c1.499 0 2.889.448 4.054 1.214l2.857-2.857a11.325 11.325 0 0 0-6.91-2.342zm9.674.756c-.292 0-.583.112-.805.334-2.97 2.965-5.934 5.934-8.9 8.902L9.596 8.854a1.139 1.139 0 0 0-1.61 0l-1.775 1.773a1.139 1.139 0 0 0 0 1.61l4.166 4.163a1.421 1.421 0 0 0 2.012 0L23.666 5.121a1.136 1.136 0 0 0 0-1.61l-1.805-1.804a1.136 1.136 0 0 0-.804-.334z',
+  google_tasks: 'M11.383.617C5.097.617 0 5.714 0 12c0 6.286 5.097 11.383 11.383 11.383 6.286 0 11.38-5.097 11.38-11.383a11.34 11.34 0 0 0-.878-4.389l-3.203 3.203c.062.387.1.782.1 1.186a7.398 7.398 0 1 1-7.4-7.398c1.499 0 2.889.448 4.054 1.214l2.857-2.857a11.325 11.325 0 0 0-6.91-2.342zm9.674.756c-.292 0-.583.112-.805.334-2.97 2.965-5.934 5.934-8.9 8.902L9.596 8.854a1.139 1.139 0 0 0-1.61 0l-1.775 1.773a1.139 1.139 0 0 0 0 1.61l4.166 4.163a1.421 1.421 0 0 0 2.012 0L23.666 5.121a1.136 1.136 0 0 0 0-1.61l-1.805-1.804a1.136 1.136 0 0 0-.804-.334z',
 };

package/src/cli/runtime/registry.ts

@@ -7,12 +7,14 @@ import { loadProfileProviders } from '#providers/custom/index.ts';
 import { loadProfileSkills, type LoadedSkill } from '#providers/skills/store.ts';
 import { exampleProvider } from '#providers/example/provider.ts';
 import {
+  assetsProvider,
   createIdentityProvider,
   createMemoryVaultStore,
   createSetupProvider,
   createSkillsProvider,
   createVaultProvider,
   memoryProvider,
+  tasksProvider,
   type IdentityProviderOptions,
   type SetupProviderOptions,
   type VaultStore,
@@ -84,8 +86,8 @@ export interface OwnerLayerOptions {
  * Statically imported for now; the registry does not care where a manifest came
  * from, which is what lets workspace YAML register alongside these.
  *
- * `allowReserved` is what admits `memory`, `skills`, `vault`, `setup`, and
- * `identity`. The guard
+ * `allowReserved` is what admits `memory`, `tasks`, `assets`, `skills`, `vault`,
+ * `setup`, and `identity`. The guard
  * stays rather than being retired: it exists so a *third-party* provider cannot
  * claim a namespace whose policy rules would then silently mean something else,
  * and that reason survives the owner layer shipping. Only this one construction
@@ -95,7 +97,13 @@ export function buildRegistry(owner: OwnerLayerOptions = {}): ProviderRegistry {
   const registry = new ProviderRegistry({ allowReserved: true });
 
   registry.register(exampleProvider);
+  // The three that hold what the owner keeps. All module-level constants rather
+  // than factories: each reads and writes through `context.storage`, which core
+  // scopes per call, so there is nothing to hand in at construction time and
+  // nothing for `OwnerLayerOptions` to carry.
   registry.register(memoryProvider);
+  registry.register(tasksProvider);
+  registry.register(assetsProvider);
   registry.register(skillsProviderFor(owner));
   registry.register(
     createVaultProvider({