@lanes-sh/link 0.4.1 → 0.5.1

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-migrate.ts

@@ -0,0 +1,251 @@
+import { ConfigError, renamedProviderFor, validateConfigShape, type Config } from '#profile';
+import type { SecretStore } from '#secrets';
+import { ConfigDocument } from './config-edit.ts';
+
+/**
+ * Applying a provider rename to a profile that still names the old id.
+ *
+ * Apart from `config-repair.ts` because the subject differs, not because either
+ * file grew: that one gives a profile a surface it never had, reading a config
+ * that loads. This one runs when the config does *not* load, which is the whole
+ * difficulty. `renamedProviderFor` refuses a stale row at load (`#profile`), and
+ * every command opens the config — so one row left saying `provider: tasks`
+ * takes `status`, `start`, `plan` and `doctor` down together, for a state an
+ * upgrade put the operator in without asking. The only way back was to
+ * hand-edit YAML, which is not a thing a CLI should require to undo its own
+ * release.
+ *
+ * So this reads raw YAML through `ConfigDocument` and edits it comment-first,
+ * exactly as the other repairs do.
+ *
+ * **It never guesses.** A `tasks` row labelled anything but `Tasks` is either a
+ * pre-rename Google Tasks connection or a hand-edited built-in one, and the
+ * refusal names both because the two fixes are opposite. What decides here is
+ * evidence rather than a heuristic: a stored credential at `tasks/<id>` can only
+ * belong to the OAuth connection, because the built-in holds none and never
+ * has. With no credential this reports both readings and changes nothing.
+ */
+
+/** One row that has to move. */
+export interface PendingRename {
+  readonly index: number;
+  readonly from: string;
+  readonly to: string;
+  readonly id: string;
+  readonly account: string;
+  /** `provider.id`, as the rest of the CLI addresses a connection. */
+  readonly key: string;
+}
+
+export interface RenameMigration {
+  /** Every stale row found, whether or not it could be moved. */
+  readonly rows: readonly PendingRename[];
+  /** What was done, or would be — spelled for display. */
+  readonly changes: readonly string[];
+  /** What was left alone, each with why. */
+  readonly blocked: readonly string[];
+}
+
+/**
+ * The rows a document still spells the old way.
+ *
+ * Raw YAML, so nothing here has been through a schema — this runs on a file the
+ * loader has already refused, and every field is whatever was typed. A row
+ * missing `provider` or `account` is not a rename, it is a shape error, and
+ * reporting that is `validateConfig`'s job rather than this one's.
+ */
+export function pendingRenames(document: ConfigDocument): PendingRename[] {
+  const pending: PendingRename[] = [];
+
+  connectionsOf(document).forEach((row, index) => {
+    const { provider, id, account } = (row ?? {}) as {
+      provider?: unknown;
+      id?: unknown;
+      account?: unknown;
+    };
+    if (typeof provider !== 'string' || typeof id !== 'string' || typeof account !== 'string') {
+      return;
+    }
+
+    const moved = renamedProviderFor({ provider, account });
+    if (moved) {
+      pending.push({ index, from: provider, to: moved.to, id, account, key: `${provider}.${id}` });
+    }
+  });
+
+  return pending;
+}
+
+/**
+ * Report what a profile is owed, and optionally apply it.
+ *
+ * Takes the credential store rather than opening one, so the caller decides
+ * whether the target is reachable and a test needs no adapter. `apply: false` is
+ * what `doctor` prints without `--fix`: the same reading against the same
+ * evidence, with nothing written.
+ *
+ * The credential is copied *before* the config is saved, and the old reference
+ * deleted only after. A crash between the two leaves a second copy of a secret
+ * the operator already holds — recoverable, and invisible. The other order
+ * leaves a config naming a credential that is gone, which presents as a
+ * connection that lost its authorisation for no reason anyone can see.
+ */
+export async function migrateRenamedProviders(
+  document: ConfigDocument,
+  credentials: SecretStore,
+  options: { apply: boolean },
+): Promise<RenameMigration> {
+  const rows = pendingRenames(document);
+  if (rows.length === 0) return { rows, changes: [], blocked: [] };
+
+  const changes: string[] = [];
+  const blocked: string[] = [];
+  const accepted: PendingRename[] = [];
+
+  for (const row of rows) {
+    if (await credentials.has(`${row.from}/${row.id}`)) {
+      accepted.push(row);
+      changes.push(`connections[${row.index}]: ${row.from} → ${row.to} (${row.key})`);
+      changes.push(`credential: ${row.from}/${row.id} → ${row.to}/${row.id}`);
+    } else {
+      blocked.push(
+        `${row.key} has no stored credential, so nothing proves it was ${row.to} rather than a ` +
+          `built-in row labelled "${row.account}" by hand — set its provider or its account in ` +
+          `the file itself`,
+      );
+    }
+  }
+
+  // The policy rules second, because whether one can move depends on what is
+  // left declaring the old id once the rows above have.
+  for (const [from, to] of new Map(accepted.map((row) => [row.from, row.to]))) {
+    const policy = renamePolicyRules(document, { from, to }, {
+      stillDeclared: keepsDeclaring(document, from, accepted),
+      apply: options.apply,
+    });
+    changes.push(...policy.changes);
+    blocked.push(...policy.blocked);
+  }
+
+  if (!options.apply || accepted.length === 0) return { rows, changes, blocked };
+
+  for (const row of accepted) {
+    document.setIn(['connections', row.index, 'provider'], row.to);
+
+    const value = await credentials.get(`${row.from}/${row.id}`);
+    if (value !== null) await credentials.set(`${row.to}/${row.id}`, value);
+  }
+
+  // Throws unless the result is a config that loads, which is the assertion
+  // worth having here — the whole premise was that it did not.
+  await document.save();
+
+  for (const row of accepted) await credentials.delete(`${row.from}/${row.id}`);
+
+  return { rows, changes, blocked };
+}
+
+/**
+ * Rewrite the policy rules that named the old id, where that is unambiguous.
+ *
+ * A rule names a provider and never an account, so `tasks.*` written for Google
+ * Tasks has to follow the rename or the migrated connection is granted nothing
+ * — `allowedConnections` drops a provider no rule covers before policy is even
+ * consulted, so the repair would land a row that serves exactly as little as
+ * the broken one did.
+ *
+ * But a profile declaring *both* — a Google Tasks row and the built-in — has one
+ * rule serving two providers, and moving it would silently revoke the one that
+ * kept its name. That profile keeps its rule and is told to add the second,
+ * which is a sentence rather than a guess at which was meant.
+ *
+ * Both lists. A `deny` written to switch Google Tasks off means it as firmly as
+ * an allow means it on, and leaving it behind would re-enable something the
+ * operator turned off.
+ */
+function renamePolicyRules(
+  document: ConfigDocument,
+  provider: { from: string; to: string },
+  options: { stillDeclared: boolean; apply: boolean },
+): { changes: string[]; blocked: string[] } {
+  const changes: string[] = [];
+  const blocked: string[] = [];
+
+  for (const field of ['allow', 'deny'] as const) {
+    const rules = document.getIn(['policy', field]) as { items?: unknown[] } | null;
+
+    (rules?.items ?? []).forEach((_item, index) => {
+      // Either spelling: a bare pattern, or `{ capability, expires_at }`. The
+      // path to it differs; the decision does not.
+      const bare = document.getIn(['policy', field, index]);
+      const path =
+        typeof bare === 'string'
+          ? (['policy', field, index] as const)
+          : (['policy', field, index, 'capability'] as const);
+
+      const capability = typeof bare === 'string' ? bare : document.getIn(path);
+      if (typeof capability !== 'string') return;
+
+      const [named, ...rest] = capability.split('.');
+      if (named !== provider.from) return;
+
+      const moved = [provider.to, ...rest].join('.');
+
+      if (options.stillDeclared) {
+        blocked.push(
+          `policy.${field} keeps "${capability}" — this profile still declares a ` +
+            `"${provider.from}" connection, so add "${moved}" rather than moving it`,
+        );
+        return;
+      }
+
+      if (options.apply) document.setIn(path, moved);
+      changes.push(`policy.${field}: ${capability} → ${moved}`);
+    });
+  }
+
+  return { changes, blocked };
+}
+
+/**
+ * Whether a row naming the old provider survives the migration.
+ *
+ * Computed against the accepted set rather than by re-reading the document,
+ * because the same answer has to hold on a report-only run, where nothing has
+ * been rewritten yet.
+ */
+function keepsDeclaring(
+  document: ConfigDocument,
+  provider: string,
+  accepted: readonly PendingRename[],
+): boolean {
+  return connectionsOf(document).some(
+    (row, index) =>
+      (row as { provider?: unknown } | null)?.provider === provider &&
+      !accepted.some((moved) => moved.index === index),
+  );
+}
+
+function connectionsOf(document: ConfigDocument): unknown[] {
+  const config = document.toJSON() as { connections?: unknown } | null;
+  return Array.isArray(config?.connections) ? config.connections : [];
+}
+
+/**
+ * The config of a document the loader has refused, shape-checked only.
+ *
+ * `openSecretStoreFor` needs a `Config` to name the target's adapter, and the
+ * document in hand fails the check that runs *after* the schema — so this is
+ * that parse without it. A document failing the schema itself is beyond this
+ * repair, and says so rather than reporting a rename it cannot see.
+ */
+export function shapeOf(document: ConfigDocument): Config {
+  try {
+    return validateConfigShape(document.toJSON(), document.path);
+  } catch (error) {
+    throw new ConfigError(
+      `${document.path} is malformed beyond a provider rename, so there is nothing to migrate.\n` +
+        `  ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

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':
@@ -273,7 +277,7 @@ export async function run(argv: readonly string[]): Promise<void> {
     case 'plan':
       return plan(global);
     case 'doctor':
-      return doctor({ ...global, json });
+      return doctor({ ...global, json, fix: flags['fix'] === true });
     case 'status':
       return status({ ...global, json });
     case 'outputs':
@@ -329,6 +333,21 @@ export async function run(argv: readonly string[]): Promise<void> {
         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',
 };