drafted 1.19.54 → 1.20.0

package/cli/drafted.mjs

@@ -394,11 +394,46 @@ program
   .command('login')
   .description('Authenticate with Drafted')
   .option('--server <url>', 'Server URL (or set DRAFTED_SERVER env var)')
+  .option('--link <code>', 'Link this computer with the one-time code from the Get set up page (no browser step)')
   .action(async (options) => {
     if (options.server) {
       process.env.DRAFTED_SERVER = options.server;
     }
 
+    // A link code names the account explicitly, so it REPLACES any existing
+    // login rather than deferring to it: the user just asked for this account.
+    if (options.link) {
+      const serverUrl = getServerUrl();
+      let data = null;
+      for (let attempt = 1; attempt <= 3 && !data; attempt++) {
+        try {
+          const res = await fetch(`${serverUrl}/auth/device/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ deviceCode: String(options.link).trim() }),
+          });
+          if (res.ok) data = await res.json();
+        } catch { /* network blip: retry */ }
+        if (!data && attempt < 3) await new Promise((r) => setTimeout(r, 2000));
+      }
+      if (data?.status !== 'approved') {
+        jsonOut(false, 'login', 'Link code expired or already used');
+        console.error('❌ That link code has expired or was already used.');
+        console.error('   Copy a fresh install command from the Get set up page on drafted.live.');
+        process.exit(1);
+      }
+      writeAuth({
+        sessionId: data.sessionId,
+        userId: data.userId || null,
+        orgId: data.orgId || null,
+        server: serverUrl,
+        updatedAt: new Date().toISOString(),
+      });
+      jsonOut(true, 'login', { sessionId: data.sessionId, userId: data.userId || null });
+      console.log('✅ This computer is linked to your Drafted account.');
+      return;
+    }
+
     const existing = readAuth();
     if (existing && existing.sessionId) {
       // Validate session is still valid server-side
@@ -1372,6 +1407,20 @@ program
     console.log(JSON.stringify(config, null, 2));
   });
 
+// Command: google-setup — walks the user through connecting their OWN Google
+// account to the local agent via Google's `gws` CLI (cli/google-setup.sh).
+program
+  .command('google-setup')
+  .description('Let your local agent read your Gmail, Drive and Calendar (read-only, via Google\'s gws CLI and your own Cloud project)')
+  .action(() => {
+    if (platform() === 'win32') {
+      console.error('Not yet available on Windows. Set up gws by hand: https://github.com/googleworkspace/cli#authentication');
+      process.exit(1);
+    }
+    const child = spawn('bash', [join(__dirname, 'google-setup.sh')], { stdio: 'inherit' });
+    child.on('exit', (code) => process.exit(code ?? 1));
+  });
+
 // Command: setup
 program
   .command('setup')

package/cli/google-setup.sh

@@ -0,0 +1,173 @@
+#!/bin/bash
+# Connect the user's OWN Google account to their local agent, through Google's
+# Workspace CLI (`gws`, npm @googleworkspace/cli) and a Cloud project THEY own.
+#
+# Why not Drafted's Google connection: full-inbox read needs a restricted Gmail
+# scope, and a restricted scope on Drafted's consent screen means an annual,
+# paid CASA assessment (see GOOGLE_SCOPES in server/lib/google-auth.mjs). On the
+# user's own project the scope is theirs, the token stays on this machine
+# (encrypted, OS keyring), and Drafted's servers never see a message. The agent
+# reads source material with `gws`; Drafted holds the work it produces.
+#
+# Run by install-mcp.sh (interactive installs only) and by `drafted google-setup`.
+#   --from-installer   remember a "no" so the auto-updater's re-runs never re-ask
+set -e
+
+FROM_INSTALLER=0
+[ "${1:-}" = "--from-installer" ] && FROM_INSTALLER=1
+
+BOLD="\033[1m"; DIM="\033[2m"; GREEN="\033[32m"; YELLOW="\033[33m"; RED="\033[31m"; RESET="\033[0m"
+say() { echo -e "    $1"; }
+ok() { echo -e "    ${GREEN}✓${RESET} $1"; }
+warn() { echo -e "    ${YELLOW}!${RESET} $1"; }
+# Prompts read the terminal, not stdin (stdin may be a pipe). DRAFTED_TTY lets
+# the test feed answers from a file.
+TTY="${DRAFTED_TTY:-/dev/tty}"
+exec 3<"$TTY" 2>/dev/null || exec 3</dev/null
+ask() { local reply; read -r -p "    $1 " reply <&3 || reply=""; echo "$reply"; }
+pause() { read -r -p "    $1 — press Enter when done " _ <&3 || true; }
+open_url() {
+  say "${DIM}$1${RESET}"
+  if command -v open >/dev/null 2>&1; then open "$1" >/dev/null 2>&1 || true
+  elif command -v xdg-open >/dev/null 2>&1; then xdg-open "$1" >/dev/null 2>&1 || true
+  fi
+}
+
+DRAFTED_HOME="$HOME/.drafted"
+DECLINED_MARKER="$DRAFTED_HOME/google-setup.declined"
+NPM_GLOBAL_PREFIX="${NPM_GLOBAL_PREFIX:-$DRAFTED_HOME/npm-global}"
+GWS_CONFIG_DIR="${GOOGLE_WORKSPACE_CLI_CONFIG_DIR:-$HOME/.config/gws}"
+# Read-only, deliberately: the agent reads with gws, and EVERY send goes through
+# Drafted's send_email action, which the user approves in the Drafted UI. A
+# send-capable gws token would be a way around that approval.
+GWS_SERVICES="gmail,drive,calendar,docs,sheets"
+APIS="gmail.googleapis.com,drive.googleapis.com,calendar-json.googleapis.com,docs.googleapis.com,sheets.googleapis.com"
+
+# `gws auth status` prints JSON; read ONE field without echoing the rest (it
+# carries the account's client id and scopes, which don't belong in a log).
+gws_status_field() {
+  "$GWS" auth status 2>/dev/null | node -e '
+    let s = ""; process.stdin.on("data", (d) => (s += d)).on("end", () => {
+      let j = {}; try { j = JSON.parse(s); } catch {}
+      const f = process.argv[1];
+      if (f === "gmail") return console.log((j.has_refresh_token && (j.scopes || []).some((x) => x.includes("/auth/gmail"))) ? "yes" : "no");
+      console.log(j[f] === undefined || j[f] === null ? "" : String(j[f]));
+    });' "$1"
+}
+
+# ── The gws CLI ─────────────────────────────────────────────────
+# Resolve Google's gws specifically: Homebrew's `gws` formula is an unrelated
+# git-workspace tool that installs a binary of the same name.
+GWS=""
+for candidate in "$NPM_GLOBAL_PREFIX/bin/gws" "$(command -v gws 2>/dev/null || true)"; do
+  if [ -n "$candidate" ] && [ -x "$candidate" ] && "$candidate" --help 2>&1 | grep -q "Google Workspace"; then
+    GWS="$candidate"; break
+  fi
+done
+# Already connected: nothing to ask. Checked BEFORE the consent prompt so an
+# interactive installer re-run doesn't re-pitch a finished setup.
+if [ -n "$GWS" ] && [ "$(gws_status_field gmail)" = "yes" ]; then
+  ok "Google is connected for your agent (gws)"
+  exit 0
+fi
+
+# ── Consent ───────────────────────────────────────────────────────
+echo ""
+echo -e "  ${BOLD}Let your agent read your Gmail, Drive and Calendar${RESET} ${DIM}(optional, ~5 minutes)${RESET}"
+say "Your agent (Claude or Codex) can then find the work already sitting in your inbox"
+say "and files, and build it out on your Drafted surface."
+say "${DIM}• Uses a Google Cloud project that YOU own — not a Drafted app.${RESET}"
+say "${DIM}• Read-only. The login token is stored encrypted on this machine only.${RESET}"
+say "${DIM}• Drafted's servers never receive your mail. Only what you ask your agent to${RESET}"
+say "${DIM}  put on a surface is uploaded.${RESET}"
+answer="$(ask "Set this up now? [y/N]")"
+case "$answer" in
+  [yY]*) /bin/rm -f "$DECLINED_MARKER" ;;
+  *)
+    [ "$FROM_INSTALLER" = 1 ] && { mkdir -p "$DRAFTED_HOME"; : > "$DECLINED_MARKER"; }
+    say "${DIM}Skipped. Run ${BOLD}drafted google-setup${RESET}${DIM} any time.${RESET}"
+    exit 0
+    ;;
+esac
+
+if [ -z "$GWS" ]; then
+  say "Installing Google's Workspace CLI (gws)..."
+  npm install -g @googleworkspace/cli --prefix "$NPM_GLOBAL_PREFIX" >/dev/null
+  GWS="$NPM_GLOBAL_PREFIX/bin/gws"
+fi
+ok "gws $("$GWS" --version 2>/dev/null | head -1 | sed 's/^gws //')"
+
+# ── Your Cloud project + OAuth client ───────────────────────────
+account_type="$(ask "Is this a Google Workspace (work/school) account, or a personal @gmail.com? [w/p]")"
+
+if [ "$(gws_status_field client_config_exists)" != "true" ]; then
+  if command -v gcloud >/dev/null 2>&1; then
+    say "gcloud found — ${BOLD}gws auth setup${RESET} will sign you in, create a project and enable the APIs."
+    "$GWS" auth setup || warn "gws auth setup did not finish — continuing with the manual steps."
+  else
+    say "${DIM}gcloud not installed — doing the same steps in the Cloud Console instead.${RESET}"
+  fi
+fi
+
+PROJECT_ID="$(gws_status_field project_id)"
+[ -z "$PROJECT_ID" ] && command -v gcloud >/dev/null 2>&1 && PROJECT_ID="$(gcloud config get-value project 2>/dev/null || true)"
+if [ -z "$PROJECT_ID" ]; then
+  say "Create a Cloud project (any name, e.g. ${BOLD}my-agent${RESET}):"
+  open_url "https://console.cloud.google.com/projectcreate"
+  PROJECT_ID="$(ask "Paste the project ID:")"
+  [ -z "$PROJECT_ID" ] && { warn "No project ID — stopping. Run ${BOLD}drafted google-setup${RESET} to resume."; exit 1; }
+fi
+ok "Project $PROJECT_ID"
+
+if [ "$(gws_status_field client_config_exists)" != "true" ]; then
+  say ""
+  say "${BOLD}a.${RESET} Enable the Gmail, Drive, Calendar, Docs and Sheets APIs (click Enable):"
+  open_url "https://console.cloud.google.com/flows/enableapi?apiid=$APIS&project=$PROJECT_ID"
+  pause "APIs enabled"
+  say "${BOLD}b.${RESET} Name the app (e.g. ${BOLD}My agent${RESET}) and pick your own email as support contact:"
+  open_url "https://console.cloud.google.com/auth/branding?project=$PROJECT_ID"
+  case "$account_type" in
+    [wW]*) say "   Audience: choose ${BOLD}Internal${RESET} — only your organisation, no review needed." ;;
+    *)     say "   Audience: choose ${BOLD}External${RESET}." ;;
+  esac
+  pause "Branding saved"
+  say "${BOLD}c.${RESET} Create an OAuth client: type ${BOLD}Desktop app${RESET} → Create → ${BOLD}Download JSON${RESET}:"
+  open_url "https://console.cloud.google.com/auth/clients/create?project=$PROJECT_ID"
+  pause "JSON downloaded"
+  secret="$(ls -t "$HOME"/Downloads/client_secret_*.json 2>/dev/null | head -1 || true)"
+  if [ -z "$secret" ]; then
+    secret="$(ask "Couldn't find client_secret_*.json in Downloads. Path to the file:")"
+  fi
+  [ -f "$secret" ] || { warn "No client file — stopping. Run ${BOLD}drafted google-setup${RESET} to resume."; exit 1; }
+  mkdir -p "$GWS_CONFIG_DIR"
+  # Moved, not copied: a client secret shouldn't be left lying in Downloads.
+  /bin/mv -f "$secret" "$GWS_CONFIG_DIR/client_secret.json"
+  chmod 600 "$GWS_CONFIG_DIR/client_secret.json"
+  ok "OAuth client saved"
+fi
+
+# External apps left in "Testing" get refresh tokens Google expires after
+# 7 days. Publishing the user's OWN unverified app is allowed for personal use
+# (Google caps unverified apps at 100 users) and makes the token long-lived.
+case "$account_type" in
+  [wW]*) ;;
+  *)
+    say ""
+    say "${BOLD}d.${RESET} Click ${BOLD}Publish app${RESET} → Confirm. Without this Google logs you out every 7 days."
+    open_url "https://console.cloud.google.com/auth/audience?project=$PROJECT_ID"
+    pause "App published"
+    ;;
+esac
+
+# ── Sign in ─────────────────────────────────────────────────────
+say ""
+say "Signing in. Google will say ${BOLD}\"Google hasn't verified this app\"${RESET} — it's your own app:"
+say "click ${BOLD}Advanced → Go to <your app> (unsafe)${RESET}, then allow read access."
+"$GWS" auth login --readonly -s "$GWS_SERVICES" || true
+
+if [ "$(gws_status_field gmail)" = "yes" ]; then
+  ok "Google connected — your agent can now read Gmail, Drive and Calendar via ${BOLD}gws${RESET}"
+  exit 0
+fi
+echo -e "    ${RED}✗${RESET} Sign-in didn't complete. Run ${BOLD}drafted google-setup${RESET} to try again."
+exit 1

package/install-mcp.sh

@@ -16,6 +16,7 @@ INSTALL_MODE="production"
 INSTALL_NAME="${DRAFTED_MCP_NAME:-drafted}"
 INSTALL_SERVER="${DRAFTED_SERVER:-$SERVER}"
 INSTALL_AUTH_FILE="${DRAFTED_AUTH_FILE:-}"
+LINK_CODE=""
 
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -39,8 +40,13 @@ while [ $# -gt 0 ]; do
       INSTALL_AUTH_FILE="$2"
       shift 2
       ;;
+    --link)
+      LINK_CODE="$2"
+      shift 2
+      ;;
     --help|-h)
-      echo "Usage: install-mcp.sh [--local] [--server URL] [--name MCP_NAME] [--auth-file PATH]"
+      echo "Usage: install-mcp.sh [--local] [--server URL] [--name MCP_NAME] [--auth-file PATH] [--link CODE]"
+      echo "  --link: one-time code from the Get set up page; links this computer to that account"
       echo "  default: installs production MCP named drafted -> https://drafted.live"
       echo "  --local: installs duplicate MCP named drafted-local -> http://localhost:3477"
       exit 0
@@ -297,6 +303,19 @@ else
 fi
 ok "Installed $(drafted --version 2>/dev/null || echo 'drafted') via npm"
 
+# The Get set up page's command carries a one-time link code for the account that
+# showed it, so the computer links without a browser hop (which could land in a
+# different account's browser). Single use, 15 minutes; failure is not fatal, the
+# agent can still sign in on first use.
+if [ -n "$LINK_CODE" ]; then
+  step "Linking this computer to your account"
+  if DRAFTED_SERVER="$INSTALL_SERVER" drafted login --link "$LINK_CODE"; then
+    ok "Linked"
+  else
+    echo -e "    ${YELLOW}Not linked. Your agent will ask you to sign in the first time it uses Drafted.${RESET}"
+  fi
+fi
+
 # ── Configure ─────────────────────────────────────────────────────
 
 step "Connecting to your tools"
@@ -1293,6 +1312,20 @@ verify_no_legacy_http_config
 report_telemetry "drafted_mcp_configured" "installed"
 report_telemetry "drafted_install" "installed"
 
+# ── Optional: Google for the local agent ─────────────────────────
+# Interactive installs only. The auto-updater re-runs this script with no
+# terminal, so it must never reach a prompt; a "no" is remembered in
+# ~/.drafted/google-setup.declined so interactive re-runs don't re-ask either.
+GOOGLE_SETUP_SCRIPT="${DRAFTED_PKG_DIR:+$DRAFTED_PKG_DIR/cli/google-setup.sh}"
+[ -f "$SCRIPT_DIR/cli/google-setup.sh" ] && GOOGLE_SETUP_SCRIPT="$SCRIPT_DIR/cli/google-setup.sh"
+if [ "$INSTALL_MODE" = "production" ] && [ "${DRAFTED_HEADLESS:-}" != "1" ] \
+  && [ -t 1 ] && { : </dev/tty; } 2>/dev/null \
+  && [ ! -f "$HOME/.drafted/google-setup.declined" ] \
+  && [ -n "$GOOGLE_SETUP_SCRIPT" ] && [ -f "$GOOGLE_SETUP_SCRIPT" ]; then
+  step "Connecting Google (optional)"
+  NPM_GLOBAL_PREFIX="$NPM_GLOBAL_PREFIX" bash "$GOOGLE_SETUP_SCRIPT" --from-installer || true
+fi
+
 # ── Done ─────────────────────────────────────────────────────────
 
 echo ""
@@ -1304,13 +1337,62 @@ echo -e "  ${DIM}Server:${RESET}    ${BOLD}$INSTALL_SERVER${RESET}"
 echo -e "  ${DIM}To update production:${RESET}  rerun the installer from drafted.live/install (curl -fsSL https://drafted.live/install.sh -o /tmp/install-drafted.sh && bash /tmp/install-drafted.sh)"
 echo -e "  ${DIM}To uninstall:${RESET}  npm uninstall -g drafted --prefix ~/.drafted/npm-global && rm -rf ~/.drafted"
 echo ""
-echo -e "${YELLOW}${BOLD}"
-echo "  ┌─────────────────────────────────────────────────────────┐"
-echo "  │                                                         │"
-echo "  │   >>>  RESTART YOUR EDITOR TO ACTIVATE DRAFTED  <<<     │"
-echo "  │                                                         │"
-echo "  │   Close and reopen Claude Desktop, Claude Code,         │"
-echo "  │   Codex, or Cursor so it picks up the new MCP server.   │"
-echo "  │                                                         │"
-echo "  └─────────────────────────────────────────────────────────┘"
-echo -e "${RESET}"
+# ── Hand-off: start the first session ───────────────────────────
+# Interactive production installs only. A fresh agent process loads the new MCP,
+# so no restart is needed, and onboard-drafted is what turns the install into a
+# first project. Without this the user is left at a banner, not knowing what to
+# type next. Anything unusual (no agent CLI, no terminal, a "no") falls back to it.
+handoff_to_agent() {
+  # DRAFTED_TTY lets tests/install-handoff.test.ts play the terminal.
+  local tty="${DRAFTED_TTY:-/dev/tty}"
+  [ "$INSTALL_MODE" = "production" ] && [ "${DRAFTED_HEADLESS:-}" != "1" ] || return 1
+  [ -n "${DRAFTED_TTY:-}" ] || [ -t 1 ] || return 1
+  # One descriptor for every answer, so a scripted terminal is read line by line.
+  exec 4<"$tty" 2>/dev/null || return 1
+  local agents=() agent="" reply
+  command -v claude >/dev/null 2>&1 && agents+=(claude)
+  command -v codex >/dev/null 2>&1 && agents+=(codex)
+  [ ${#agents[@]} -gt 0 ] || return 1
+  step "Start your first project"
+  read -r -p "    Start it now in your agent? [Y/n] " reply <&4 || reply="n"
+  case "$reply" in [nN]*) return 1 ;; esac
+  if [ ${#agents[@]} -eq 1 ]; then
+    agent="${agents[0]}"
+  else
+    read -r -p "    Which agent do you use? 1) Claude Code  2) Codex [1] " reply <&4 || reply=""
+    case "$reply" in 2*) agent="codex" ;; *) agent="claude" ;; esac
+  fi
+  if [ ! -s "$HOME/.drafted/auth.json" ]; then
+    echo -e "    Signing in to Drafted (a browser tab opens; approve it there)"
+    DRAFTED_SERVER="$INSTALL_SERVER" drafted login <"$tty" || return 1
+  fi
+  local url="$INSTALL_SERVER/?setup=1"
+  echo -e "    Opening your surface: ${BOLD}$url${RESET}"
+  echo -e "    ${DIM}Signed up in a different browser or a private window? Open that link there.${RESET}"
+  if command -v open >/dev/null 2>&1; then open "$url" >/dev/null 2>&1 || true
+  elif command -v xdg-open >/dev/null 2>&1; then xdg-open "$url" >/dev/null 2>&1 || true
+  fi
+  if [ "$agent" = "claude" ]; then
+    echo -e "    Starting Claude Code with ${BOLD}/drafted:onboard-drafted${RESET}..."
+    exec claude "/drafted:onboard-drafted" <"$tty"
+  fi
+  # Codex has no namespaced slash command for it: pass the command's own text.
+  local cmd_file="${PLUGIN_SRC:-}/commands/onboard-drafted.md" prompt="Run the Drafted onboarding (the onboard-drafted command)."
+  if [ -f "$cmd_file" ]; then
+    prompt="$(awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2' "$cmd_file" | sed 's/\$ARGUMENTS//g')"
+  fi
+  echo -e "    Starting Codex with the Drafted onboarding..."
+  exec codex "$prompt" <"$tty"
+}
+handoff_to_agent || {
+  echo -e "${YELLOW}${BOLD}"
+  echo "  ┌─────────────────────────────────────────────────────────┐"
+  echo "  │                                                         │"
+  echo "  │   >>>  RESTART YOUR EDITOR TO ACTIVATE DRAFTED  <<<     │"
+  echo "  │                                                         │"
+  echo "  │   Close and reopen Claude Desktop, Claude Code,         │"
+  echo "  │   Codex, or Cursor so it picks up the new MCP server.   │"
+  echo "  │                                                         │"
+  echo "  └─────────────────────────────────────────────────────────┘"
+  echo -e "${RESET}"
+}

package/mcp/gws-status.mjs

@@ -0,0 +1,31 @@
+// Local-capability probe for the Get set up page (see mcp/server.mjs, agent-capabilities).
+// Its own module so tests can import it without opening the MCP WebSocket.
+import { execFile } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Is Google's Workspace CLI signed in for this user, with Gmail readable?
+ * 'ready' | 'signed_out' | 'absent'. Checks the Drafted npm prefix first (where
+ * `drafted google-setup` installs it, and which a GUI-launched agent's PATH may
+ * lack), then PATH. Anything that is not Google's gws (Homebrew's `gws` is an
+ * unrelated tool) prints non-JSON and reads as 'absent'.
+ */
+export function gwsStatusFromJson(stdout) {
+  try {
+    const j = JSON.parse(stdout);
+    return j.has_refresh_token && (j.scopes || []).some((x) => String(x).includes('/auth/gmail')) ? 'ready' : 'signed_out';
+  } catch {
+    return 'absent';
+  }
+}
+export function detectGwsStatus({ candidates = [join(homedir(), '.drafted', 'npm-global', 'bin', 'gws'), 'gws'] } = {}) {
+  const tryOne = (i) => new Promise((resolve) => {
+    if (i >= candidates.length) return resolve('absent');
+    execFile(candidates[i], ['auth', 'status'], { timeout: 5000, windowsHide: true }, (err, stdout) => {
+      if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) return resolve(tryOne(i + 1));
+      resolve(gwsStatusFromJson(String(stdout || '')));
+    });
+  });
+  return tryOne(0).catch(() => 'absent');
+}

package/mcp/server.mjs

@@ -13,6 +13,7 @@ import { createHash } from 'node:crypto';
 import { readFileSync, existsSync, realpathSync, writeFileSync, mkdirSync, unlinkSync, appendFileSync, readdirSync, statSync } from 'fs';
 import { join, dirname, basename, extname, resolve } from 'path';
 import { homedir, platform, release as osRelease, arch as osArch } from 'os';
+import { detectGwsStatus } from './gws-status.mjs';
 import { fileURLToPath } from 'url';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { z } from 'zod';
@@ -430,7 +431,9 @@ LINKING: link the user to the narrowest thing you touched, never the project as
 
 DUAL REGISTRATION IS NORMAL: a separate "Drafted" remote connector (https://drafted.live/mcp, managed by claude.ai) may appear alongside this local stdio server in MCP listings. It is NOT a duplicate and NOT broken — it serves claude.ai web/mobile/Cowork, where a local stdio process cannot run. Never advise removing it; a "needs authentication" state on it is fixed by signing in from claude.ai and does not affect this stdio session.${isRemote ? `
 
-PLUGIN vs BARE CONNECTOR: Drafted ships as a plugin that bundles these tools WITH the Drafted skill and eight slash commands (/drafted:onboard-drafted, /drafted:create-project, /drafted:create-skill, /drafted:ingest, /drafted:extract, /drafted:improve-wiki, /drafted:improve-skill, /drafted:improve-project-harness). If the user added only the connector URL, they have the tools but none of that — the guidance for HOW to use the surface well is in the skill and commands they are missing. If the user asks where the slash commands are, or seems to be missing Drafted guidance, tell them: Settings → Customize plugins → Add → Add marketplace → ddfourtwo/drafted-web → install Drafted, then sign in when prompted. Mention it once, do not nag.` : ''}`,
+PLUGIN vs BARE CONNECTOR: Drafted ships as a plugin that bundles these tools WITH the Drafted skill and eight slash commands (/drafted:onboard-drafted, /drafted:create-project, /drafted:create-skill, /drafted:ingest, /drafted:extract, /drafted:improve-wiki, /drafted:improve-skill, /drafted:improve-project-harness). If the user added only the connector URL, they have the tools but none of that — the guidance for HOW to use the surface well is in the skill and commands they are missing. If the user asks where the slash commands are, or seems to be missing Drafted guidance, tell them: Settings → Customize plugins → Add → Add marketplace → ddfourtwo/drafted-web → install Drafted, then sign in when prompted. Mention it once, do not nag.` : `
+
+GOOGLE SOURCE MATERIAL: if the local \`gws\` CLI (Google Workspace CLI) is signed in, it is the user's OWN read-only access to their Gmail, Drive and Calendar. Use it to find source material and build the result in Drafted. Ask before the first read, read headers before bodies, and link back to sources rather than pasting email into frames. gws is read-only: EVERY email send goes through action(propose, type="send_email"), which the user must approve in the Drafted UI; never send by any other route. Not set up? The user can run \`drafted google-setup\`. Full rules: the drafted skill's "Source material from Google" section.`}`,
 });
 
 const layerKeys = Object.keys(LAYERS);
@@ -1799,6 +1802,11 @@ async function connectAgentWs() {
     // suggestedName (basename of the working directory) lets the server offer it in the
     // name-before-work gate message and as the tab placeholder.
     try { agentWs.send(JSON.stringify({ type: 'agent-hello', agentLabel: getAgentLabel(), suggestedName: getSuggestedSessionName() })); } catch {}
+    // Local capabilities for the Get set up page: only a status word, never the
+    // Google account, scopes or client. Same open-race guard as the hello.
+    if (!isRemote) detectGwsStatus().then((gws) => {
+      try { if (agentWs?.readyState === 1) agentWs.send(JSON.stringify({ type: 'agent-capabilities', gws })); } catch {}
+    });
     // Same open-race guard as the hello above: the socket can leave 'open' before
     // this second send lands, and an unguarded throw here kills the stdio child
     // (taking the agent's whole MCP connection with it) for a presence message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.19.54",
+  "version": "1.20.0",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "files": [

package/plugin/commands/onboard-drafted.md

@@ -9,9 +9,10 @@ This is the over-arching prime command: orient, then seed all three stores so ev
 
 1. **Orient** — in 3-4 lines explain the loop: you *prime* from the harness (the system makes you search the wiki, and auto-loads the project's attached skills, anchors, and layer rules before you work), you *build*, then you *compound* (deposit what you learned). The more it's used, the less searching and the more stable the work. Drafted is navigated like a filesystem — one `fs` tool, three roots: `/wiki`, `/skills`, `/projects`.
 2. **Name the org** — the org is an address, not a cursor: address wiki/skills with `org=...` on the call, and projects self-derive their org from the path. Never rely on an "active" org: a project-less create by a multi-org user is refused rather than guessed.
-3. **Seed knowledge** — run the `/drafted:ingest` flow: help the user point at existing business materials (folders, docs, past research) or interrogate them for tacit knowledge, and land durable pages in the wiki.
-4. **Seed procedures** — from those materials and the conversation, surface 1-3 candidate SOPs. For the most valuable, run the `/drafted:create-skill` flow.
-5. **Seed the surface** — run the `/drafted:create-project` flow for the user's immediate piece of work (or a reusable template).
-6. Close by showing what now exists (wiki pages, skills, project) and restate the one-line loop: prime → build → compound.
+3. **Find the work (ask first).** Make your first question permission, offering three scopes, narrowest first: (a) "tell me what you're working on this week" (nothing is read), (b) one folder they point you to, (c) recent files plus their inbox, Drive and calendar. Option (c) needs `gws` signed in; check it as the `drafted` skill's *Source material from Google* section describes, and if it isn't, offer `! drafted google-setup`. Say plainly what stays on their machine (everything you read) and what reaches Drafted (only what they pick). Read headers before bodies. Then write one frame, **Your work, mapped**: the 3-7 strongest candidates for a Drafted project, each with why it fits (many artifacts, several people, a recurring process, a decision to make), its source links, and the project it would become. Let the user pick.
+4. **Seed knowledge** — run the `/drafted:ingest` flow: help the user point at existing business materials (folders, docs, past research, the sources behind the candidate they picked) or interrogate them for tacit knowledge, and land durable pages in the wiki.
+5. **Seed procedures** — from those materials and the conversation, surface 1-3 candidate SOPs. For the most valuable, run the `/drafted:create-skill` flow.
+6. **Seed the surface** — run the `/drafted:create-project` flow for the candidate the user picked, or their immediate piece of work (or a reusable template).
+7. Close by showing what now exists (wiki pages, skills, project) and restate the one-line loop: prime → build → compound.
 
 Keep it guided and conversational — one step at a time, confirming before each deposit. Don't dump everything at once.

package/plugin/skills/drafted/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: drafted
-description: Use the Drafted producibles harness — a compounding workspace that uplifts any AI across three primitives: knowledge (the org wiki), procedures (skills), and the project surface (frames on a shared real-time canvas). Drafted is navigated like a filesystem — one fs tool, one path grammar, org first: `fs(ls, path="/")` lists your orgs, then `/o/<org>/<root>/...`. Prime from the harness before working, build durable artifacts as frames instead of burying output in chat, and deposit what you learned back so the next session starts smarter. When Google Drive is connected, prefer Google Workspace frames for docs, sheets, and slides.
+description: Use the Drafted producibles harness — a compounding workspace that uplifts any AI across three primitives: knowledge (the org wiki), procedures (skills), and the project surface (frames on a shared real-time canvas). Drafted is navigated like a filesystem — one fs tool, one path grammar, org first: `fs(ls, path="/")` lists your orgs, then `/o/<org>/<root>/...`. Prime from the harness before working, build durable artifacts as frames instead of burying output in chat, and deposit what you learned back so the next session starts smarter. When Google Drive is connected, prefer Google Workspace frames for docs, sheets, and slides. When the local `gws` CLI is signed in, read the user's Gmail, Drive and Calendar with it as source material and build the result in Drafted.
 ---
 
 # Drafted — a producibles harness that compounds
@@ -69,6 +69,16 @@ These bookend the loop. Prime/feed at the start, deposit at the end.
 - **`fs(mv, from="/o/<org>/projects/<p>/<layer>/<lane>/<file>", to="...")`** renames or moves (cross-project too). **`fs(rm, path="/o/<org>/projects/<project>")` archives** — agents never hard-delete; the archive is in the web UI.
 - **Return a clickable link** for what you touched — the `frameUrl`/`projectUrl` in the fs response is the URL the user opens.
 
+## Source material from Google (`gws`) — Drafted holds the work
+
+Local sessions may have Google's Workspace CLI, `gws`, signed in **read-only** to the user's **own** Google account (set up by the installer or `drafted google-setup`). Split the jobs: **`gws` reads what already exists** (mail, Drive files, calendar) on the user's machine with the user's token. **Drafted is where what you make from it lives, and the only way anything is sent.** Don't use Drafted as a mail store, and don't leave the result in chat.
+
+- **Check first.** `gws auth status` is ready when `has_refresh_token` is `true` and a scope contains `/auth/gmail`. Read those two fields; don't echo the whole output. If it isn't ready, suggest `! drafted google-setup` once (macOS/Linux; it's interactive, so the user runs it). Remote sessions (claude.ai, `/mcp`) have no `gws`, so skip this section there.
+- **Ask before you read.** The first inbox or Drive read in a session needs the user's yes and a scope ("last 30 days", "threads with Acme", "this folder"). Offer the narrowest useful one.
+- **Headers before bodies.** List with `gws gmail users threads list --params '{"userId":"me","q":"newer_than:30d -category:promotions -category:social","maxResults":50}'`. Get headers with `gws gmail users threads get --params '{"userId":"me","id":"<threadId>","format":"metadata","metadataHeaders":["From","Subject","Date"]}'` and triage on subject, participants and date. Open a body (`gws gmail +read --id <messageId>`) only for threads you will actually use. Drive: `gws drive files list --params '{"q":"trashed = false","orderBy":"modifiedTime desc","pageSize":50,"fields":"files(id,name,mimeType,modifiedTime,webViewLink)"}'`. When unsure of a method's shape, run `gws schema <service.resource.method>`.
+- **Synthesize, never copy.** A frame or wiki page carries your synthesis plus a link back to the source (`https://mail.google.com/mail/u/0/#all/<threadId>`, or the Drive file's `webViewLink`). It never carries pasted email bodies or other people's addresses. The surface is shared with collaborators; the inbox is not. Quote only what the user asks for, attributed.
+- **Every send goes through Drafted, and the user approves it.** `gws` is signed in read-only, and it stays that way. To send, draft the email, then `action(action="propose", type="send_email", payload='{"from":"<the user\'s own connected Gmail address>","to":"<one address>","subject":"<one line>","body":"<plain text>"}', reason="<one line: why>")`. The user reads it and approves it in the Drafted UI. Nothing is sent before that, and you cannot approve it yourself. It goes out AS the user, from their Gmail connected in Drafted Settings; if the proposal is refused because none is connected, tell them to connect it there. Never send by any other route (widening the `gws` sign-in, SMTP, another tool), even when asked to "just send it": propose, and point the user to the approval.
+
 ## Quality conventions
 
 - **Match format to layer intent.** Research/strategy/copy are usually markdown; visual work (wireframes, designs, dashboards) is HTML.