@bretwardjames/tw-bridge 0.3.0 → 0.5.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs2 from "fs";
-import path3 from "path";
-import os2 from "os";
+import fs4 from "fs";
+import path5 from "path";
+import os4 from "os";
 
 // src/config.ts
 import fs from "fs";
@@ -30,7 +30,7 @@ function loadConfig() {
 function saveConfig(config) {
   const configPath = findConfigPath() ?? CONFIG_PATHS[0];
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
   return configPath;
 }
 
@@ -125,9 +125,11 @@ var GhpAdapter = class {
       process.stderr.write("tw-bridge [ghp]: task has no backend_id, skipping ghp start\n");
       return;
     }
-    process.stderr.write(`tw-bridge [ghp]: starting issue #${issueNumber}
+    const parallel = process.env.TW_BRIDGE_MODE === "parallel";
+    const args = parallel ? ["start", issueNumber, "--parallel"] : ["start", issueNumber];
+    process.stderr.write(`tw-bridge [ghp]: starting issue #${issueNumber}${parallel ? " (parallel)" : ""}
 `);
-    const result = spawnSync("ghp", ["start", issueNumber], {
+    const result = spawnSync("ghp", args, {
       cwd: this.config.cwd,
       stdio: [ttyFd, ttyFd, ttyFd]
     });
@@ -150,9 +152,430 @@ var GhpAdapter = class {
   }
 };
 
+// src/adapters/asana.ts
+import fs2 from "fs";
+import path3 from "path";
+import os2 from "os";
+import { execSync } from "child_process";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+var API_BASE = "https://app.asana.com/api/1.0";
+var OAUTH_AUTHORIZE = "https://app.asana.com/-/oauth_authorize";
+var OAUTH_TOKEN = "https://app.asana.com/-/oauth_token";
+var OOB_REDIRECT = "urn:ietf:wg:oauth:2.0:oob";
+var TOKEN_FILE = path3.join(os2.homedir(), ".config", "tw-bridge", "asana-tokens.json");
+function loadTokens() {
+  try {
+    return JSON.parse(fs2.readFileSync(TOKEN_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveTokens(tokens) {
+  fs2.mkdirSync(path3.dirname(TOKEN_FILE), { recursive: true });
+  fs2.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken(tokens) {
+  const now = Date.now();
+  if (tokens.access_token && tokens.expires_at > now + 3e5) {
+    return tokens.access_token;
+  }
+  const res = await fetch(OAUTH_TOKEN, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: tokens.client_id,
+      client_secret: tokens.client_secret,
+      refresh_token: tokens.refresh_token
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  tokens.access_token = data.access_token;
+  tokens.expires_at = now + (data.expires_in ?? 3600) * 1e3;
+  saveTokens(tokens);
+  return tokens.access_token;
+}
+async function oauthLogin(clientId, clientSecret, rl) {
+  const authUrl = `${OAUTH_AUTHORIZE}?client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(OOB_REDIRECT)}&response_type=code`;
+  console.log(`
+  Opening browser for authorization...`);
+  console.log(`  If it doesn't open, visit:
+  ${authUrl}
+`);
+  try {
+    execSync(`xdg-open "${authUrl}" 2>/dev/null || open "${authUrl}" 2>/dev/null`, {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  const code = (await rl.question("  Paste the authorization code: ")).trim();
+  if (!code) throw new Error("No authorization code provided");
+  const tokenRes = await fetch(OAUTH_TOKEN, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: OOB_REDIRECT,
+      code
+    })
+  });
+  if (!tokenRes.ok) {
+    const body = await tokenRes.text();
+    throw new Error(`Token exchange failed (${tokenRes.status}): ${body}`);
+  }
+  const data = await tokenRes.json();
+  const tokens = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + (data.expires_in ?? 3600) * 1e3,
+    client_id: clientId,
+    client_secret: clientSecret
+  };
+  saveTokens(tokens);
+  return tokens;
+}
+async function asanaFetch(path6, token, options = {}) {
+  const url = `${API_BASE}${path6}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Asana API ${res.status}: ${body}`);
+  }
+  const json = await res.json();
+  return json.data;
+}
+async function asanaFetchAll(path6, token) {
+  const results = [];
+  let nextPage = path6;
+  while (nextPage) {
+    const url = `${API_BASE}${nextPage}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Asana API ${res.status}: ${body}`);
+    }
+    const json = await res.json();
+    results.push(...json.data);
+    if (json.next_page?.path) {
+      nextPage = json.next_page.path;
+    } else {
+      nextPage = null;
+    }
+  }
+  return results;
+}
+async function prompt(rl, question) {
+  return rl.question(question);
+}
+async function pickOne(rl, label, items) {
+  console.log(`
+${label}:`);
+  for (let i = 0; i < items.length; i++) {
+    console.log(`  ${i + 1}) ${items[i].name}`);
+  }
+  while (true) {
+    const answer = await prompt(rl, `Choose (1-${items.length}): `);
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < items.length) return items[idx];
+    console.log("  Invalid choice, try again.");
+  }
+}
+var AsanaAdapter = class {
+  name = "asana";
+  config;
+  accessToken = null;
+  /**
+   * Resolve the access token based on auth config.
+   * - "oauth": load from token file, refresh if needed
+   * - "env:VAR": read from environment
+   * - anything else: treat as raw PAT
+   */
+  async resolveToken() {
+    const auth = this.config.auth;
+    if (auth === "oauth") {
+      const tokens = loadTokens();
+      if (!tokens) throw new Error("No OAuth tokens found. Run `tw-bridge add` to authenticate.");
+      this.accessToken = await refreshAccessToken(tokens);
+      return this.accessToken;
+    }
+    if (this.accessToken) return this.accessToken;
+    if (auth.startsWith("env:")) {
+      const envVar = auth.slice(4);
+      const val = process.env[envVar];
+      if (!val) throw new Error(`Environment variable ${envVar} not set`);
+      this.accessToken = val;
+      return val;
+    }
+    this.accessToken = auth;
+    return auth;
+  }
+  defaultConfig(_cwd) {
+    return {
+      auth: "env:ASANA_TOKEN",
+      workspace_gid: "",
+      project_gid: "",
+      project_name: "",
+      sections: [],
+      done_sections: []
+    };
+  }
+  async setup(_cwd) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      console.log("\n\u2500\u2500 Asana Adapter Setup \u2500\u2500\n");
+      console.log("Authentication:");
+      console.log("  1) OAuth (browser login)");
+      console.log("  2) Personal Access Token");
+      console.log("  3) Environment variable");
+      const authChoice = await prompt(rl, "\nChoose (1-3): ");
+      let authConfig;
+      let token;
+      if (authChoice.trim() === "1") {
+        const clientId = (await prompt(rl, "\nAsana App Client ID: ")).trim();
+        const clientSecret = (await prompt(rl, "Asana App Client Secret: ")).trim();
+        if (!clientId || !clientSecret) {
+          console.error("\n  Client ID and Secret are required.");
+          console.error("  Create an app at: https://app.asana.com/0/my-apps");
+          console.error('  Check "This is a native or command-line app"');
+          rl.close();
+          process.exit(1);
+        }
+        const tokens = await oauthLogin(clientId, clientSecret, rl);
+        token = tokens.access_token;
+        authConfig = "oauth";
+      } else if (authChoice.trim() === "3") {
+        const envVar = await prompt(rl, "Environment variable name [ASANA_TOKEN]: ");
+        const varName = envVar.trim() || "ASANA_TOKEN";
+        authConfig = `env:${varName}`;
+        token = process.env[varName] ?? "";
+        if (!token) {
+          console.log(`
+  Warning: ${varName} is not currently set.`);
+          const tempToken = await prompt(rl, "  Paste a temporary token for setup (or Enter to skip): ");
+          token = tempToken.trim();
+          if (!token) {
+            console.error(`
+  Cannot complete setup without a valid token.`);
+            console.error(`  Set ${varName} in your environment and try again.`);
+            rl.close();
+            process.exit(1);
+          }
+        }
+      } else {
+        token = (await prompt(rl, "Paste your Personal Access Token: ")).trim();
+        authConfig = token;
+      }
+      console.log("\nVerifying...");
+      let me;
+      try {
+        me = await asanaFetch("/users/me", token);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  Authentication failed: ${msg}`);
+        rl.close();
+        process.exit(1);
+      }
+      console.log(`  Authenticated as: ${me.name} (${me.email})`);
+      const workspaces = await asanaFetch("/workspaces", token);
+      let workspace;
+      if (workspaces.length === 1) {
+        workspace = workspaces[0];
+        console.log(`
+Workspace: ${workspace.name}`);
+      } else {
+        workspace = await pickOne(rl, "Select workspace", workspaces);
+      }
+      const projects = await asanaFetchAll(
+        `/workspaces/${workspace.gid}/projects?limit=100&archived=false`,
+        token
+      );
+      if (projects.length === 0) {
+        console.error("\n  No projects found in this workspace.");
+        rl.close();
+        process.exit(1);
+      }
+      const project = await pickOne(rl, "Select project", projects);
+      const sections = await asanaFetch(
+        `/projects/${project.gid}/sections`,
+        token
+      );
+      console.log(`
+Sections in "${project.name}":`);
+      console.log("Map each section to a Taskwarrior tag (or press Enter for default).\n");
+      const sectionMappings = [];
+      const doneSections = [];
+      for (const section of sections) {
+        const defaultTag = section.name.toLowerCase().replace(/\s+/g, "_");
+        const tag = await prompt(rl, `  "${section.name}" \u2192 tag [${defaultTag}]: `);
+        const finalTag = tag.trim() || defaultTag;
+        sectionMappings.push({
+          gid: section.gid,
+          name: section.name,
+          tag: finalTag
+        });
+      }
+      console.log("\nWhich sections represent completed tasks?");
+      for (let i = 0; i < sectionMappings.length; i++) {
+        console.log(`  ${i + 1}) ${sectionMappings[i].name} (${sectionMappings[i].tag})`);
+      }
+      const doneAnswer = await prompt(rl, "Enter numbers separated by commas (e.g., 4,5): ");
+      for (const num of doneAnswer.split(",")) {
+        const idx = parseInt(num.trim(), 10) - 1;
+        if (idx >= 0 && idx < sectionMappings.length) {
+          doneSections.push(sectionMappings[idx].gid);
+        }
+      }
+      console.log("\nWhich section should tasks move to on `task start`?");
+      for (let i = 0; i < sectionMappings.length; i++) {
+        console.log(`  ${i + 1}) ${sectionMappings[i].name}`);
+      }
+      console.log(`  0) Don't move (no action on start)`);
+      const startAnswer = await prompt(rl, "Choose: ");
+      const startIdx = parseInt(startAnswer.trim(), 10) - 1;
+      const startSectionGid = startIdx >= 0 && startIdx < sectionMappings.length ? sectionMappings[startIdx].gid : void 0;
+      rl.close();
+      console.log(`
+  Project: ${project.name}`);
+      console.log(`  Sections: ${sectionMappings.map((s) => s.tag).join(", ")}`);
+      console.log(`  Done: ${doneSections.length} section(s)`);
+      if (startSectionGid) {
+        const startSection = sectionMappings.find((s) => s.gid === startSectionGid);
+        console.log(`  On start: move to "${startSection?.name}"`);
+      }
+      return {
+        auth: authConfig,
+        workspace_gid: workspace.gid,
+        project_gid: project.gid,
+        project_name: project.name,
+        sections: sectionMappings,
+        done_sections: doneSections,
+        start_section_gid: startSectionGid
+      };
+    } catch (err) {
+      rl.close();
+      throw err;
+    }
+  }
+  async init(config) {
+    this.config = config;
+    if (!this.config.project_gid) {
+      throw new Error('asana adapter requires "project_gid" in config');
+    }
+  }
+  async pull() {
+    const token = await this.resolveToken();
+    const fields = [
+      "gid",
+      "name",
+      "completed",
+      "completed_at",
+      "assignee",
+      "assignee.name",
+      "memberships.project",
+      "memberships.project.name",
+      "memberships.section",
+      "memberships.section.name",
+      "permalink_url",
+      "custom_fields",
+      "custom_fields.name",
+      "custom_fields.display_value"
+    ].join(",");
+    const asanaTasks = await asanaFetchAll(
+      `/projects/${this.config.project_gid}/tasks?opt_fields=${fields}&limit=100`,
+      token
+    );
+    const tasks = [];
+    const sectionMap = new Map(
+      this.config.sections.map((s) => [s.gid, s])
+    );
+    for (const at of asanaTasks) {
+      if (at.completed) continue;
+      const membership = at.memberships?.find(
+        (m) => m.project.gid === this.config.project_gid
+      );
+      const sectionGid = membership?.section?.gid;
+      const sectionMapping = sectionGid ? sectionMap.get(sectionGid) : null;
+      const tags = [];
+      if (sectionMapping) tags.push(sectionMapping.tag);
+      const priority = mapAsanaPriority(at.custom_fields);
+      const task = {
+        uuid: "",
+        description: at.name,
+        status: "pending",
+        entry: (/* @__PURE__ */ new Date()).toISOString(),
+        project: this.config.project_name,
+        tags,
+        priority,
+        backend: "",
+        backend_id: at.gid,
+        annotations: at.permalink_url ? [{ entry: (/* @__PURE__ */ new Date()).toISOString(), description: at.permalink_url }] : void 0
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  async onStart(task, _ttyFd) {
+    if (!this.config.start_section_gid) return;
+    const taskGid = task.backend_id;
+    if (!taskGid) return;
+    const token = await this.resolveToken();
+    const startSection = this.config.sections.find(
+      (s) => s.gid === this.config.start_section_gid
+    );
+    process.stderr.write(
+      `tw-bridge [asana]: moving task to "${startSection?.name ?? "In Progress"}"
+`
+    );
+    await asanaFetch(`/sections/${this.config.start_section_gid}/addTask`, token, {
+      method: "POST",
+      body: JSON.stringify({ data: { task: taskGid } })
+    });
+  }
+  async onDone(task) {
+    const taskGid = task.backend_id;
+    if (!taskGid) return;
+    const token = await this.resolveToken();
+    process.stderr.write(`tw-bridge [asana]: marking task complete
+`);
+    await asanaFetch(`/tasks/${taskGid}`, token, {
+      method: "PUT",
+      body: JSON.stringify({ data: { completed: true } })
+    });
+  }
+};
+function mapAsanaPriority(fields) {
+  if (!fields) return void 0;
+  const pField = fields.find(
+    (f) => f.name.toLowerCase() === "priority" && f.display_value
+  );
+  if (!pField?.display_value) return void 0;
+  const val = pField.display_value.toLowerCase();
+  if (val.startsWith("high") || val === "urgent" || val === "p0" || val === "p1") return "H";
+  if (val.startsWith("med") || val === "p2") return "M";
+  if (val.startsWith("low") || val === "p3" || val === "p4") return "L";
+  return void 0;
+}
+
 // src/registry.ts
 var BUILTIN_ADAPTERS = {
-  ghp: () => new GhpAdapter()
+  ghp: () => new GhpAdapter(),
+  asana: () => new AsanaAdapter()
 };
 function matchBackend(task, config) {
   if (task.backend && config.backends[task.backend]) {
@@ -284,12 +707,65 @@ function updateTaskDescription(existing, newDescription) {
   return result.status === 0;
 }
 
+// src/tracking.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { spawnSync as spawnSync3 } from "child_process";
+var TRACKING_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", "tracking.json");
+function loadTracking() {
+  try {
+    return JSON.parse(fs3.readFileSync(TRACKING_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveTracking(state) {
+  fs3.mkdirSync(path4.dirname(TRACKING_FILE), { recursive: true });
+  fs3.writeFileSync(TRACKING_FILE, JSON.stringify(state));
+}
+function mergedTags(state) {
+  const all = /* @__PURE__ */ new Set();
+  for (const tags of Object.values(state)) {
+    for (const tag of tags) all.add(tag);
+  }
+  return [...all];
+}
+function startParallel(key, tags) {
+  const tracking = loadTracking();
+  tracking[key] = tags;
+  saveTracking(tracking);
+  const merged = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...merged], { stdio: "pipe" });
+}
+function startSwitch(key, tags) {
+  saveTracking({ [key]: tags });
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...tags], { stdio: "pipe" });
+}
+function stopEntry(key) {
+  const tracking = loadTracking();
+  delete tracking[key];
+  saveTracking(tracking);
+  const remaining = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  if (remaining.length > 0) {
+    spawnSync3("timew", ["start", ...remaining], { stdio: "pipe" });
+  }
+}
+function getActiveMeetings() {
+  const tracking = loadTracking();
+  return Object.entries(tracking).filter(([key]) => key.startsWith("meeting:")).map(([key, tags]) => ({ key, tags }));
+}
+
 // src/cli.ts
-var HOOKS_DIR = path3.join(os2.homedir(), ".task", "hooks");
+var HOOKS_DIR = path5.join(os4.homedir(), ".task", "hooks");
 var commands = {
   add: addBackend,
   install,
   sync,
+  meeting: meetingCmd,
   timewarrior: timewarriorCmd,
   which,
   config: showConfig
@@ -299,9 +775,10 @@ async function main() {
   if (!command || command === "--help") {
     console.log("Usage: tw-bridge <command>\n");
     console.log("Commands:");
-    console.log("  add       Add a new backend instance");
-    console.log("  install   Install Taskwarrior hooks and shell integration");
+    console.log("  add         Add a new backend instance");
+    console.log("  install     Install Taskwarrior hooks and shell integration");
     console.log("  sync        Pull tasks from all backends");
+    console.log("  meeting     Track meetings in Timewarrior (no task created)");
     console.log("  timewarrior Manage Timewarrior integration");
     console.log("  which       Print the context for the current directory");
     console.log("  config      Show current configuration");
@@ -346,14 +823,23 @@ Available adapters: ${listAdapterTypes().join(", ")}`);
   }
   const matchTag = tagOverride ?? name;
   const cwd = process.cwd();
-  const adapterConfig = adapter.defaultConfig(cwd);
+  const adapterConfig = adapter.setup ? await adapter.setup(cwd) : adapter.defaultConfig(cwd);
+  let doneStatuses;
+  const sections = adapterConfig.sections;
+  const doneSectionGids = adapterConfig.done_sections;
+  if (sections?.length && doneSectionGids?.length) {
+    const gidSet = new Set(doneSectionGids);
+    doneStatuses = sections.filter((s) => gidSet.has(s.gid)).map((s) => s.tag);
+  }
   config.backends[name] = {
     adapter: adapterType,
     match: { tags: [matchTag] },
+    ...doneStatuses?.length && { done_statuses: doneStatuses },
     config: adapterConfig
   };
   const configPath = saveConfig(config);
-  console.log(`Added backend "${name}" (adapter: ${adapterType})`);
+  console.log(`
+Added backend "${name}" (adapter: ${adapterType})`);
   console.log(`Config: ${configPath}`);
   console.log(`Match tag: +${matchTag}`);
   if (adapterConfig.cwd) {
@@ -368,18 +854,18 @@ Available adapters: ${listAdapterTypes().join(", ")}`);
 Use 'task context ${matchTag}' to switch to this project.`);
 }
 async function install() {
-  fs2.mkdirSync(HOOKS_DIR, { recursive: true });
-  const hookSource = path3.resolve(
-    path3.dirname(new URL(import.meta.url).pathname),
+  fs4.mkdirSync(HOOKS_DIR, { recursive: true });
+  const hookSource = path5.resolve(
+    path5.dirname(new URL(import.meta.url).pathname),
     "hooks",
     "on-modify.js"
   );
-  const hookTarget = path3.join(HOOKS_DIR, "on-modify.tw-bridge");
-  if (fs2.existsSync(hookTarget)) {
-    fs2.unlinkSync(hookTarget);
+  const hookTarget = path5.join(HOOKS_DIR, "on-modify.tw-bridge");
+  if (fs4.existsSync(hookTarget)) {
+    fs4.unlinkSync(hookTarget);
   }
-  fs2.symlinkSync(hookSource, hookTarget);
-  fs2.chmodSync(hookSource, 493);
+  fs4.symlinkSync(hookSource, hookTarget);
+  fs4.chmodSync(hookSource, 493);
   console.log(`Installed hook: ${hookTarget} -> ${hookSource}`);
   console.log("\nAdd these to your .taskrc:\n");
   console.log("# --- tw-bridge UDAs ---");
@@ -395,22 +881,145 @@ async function install() {
   console.log("urgency.user.tag.in_review.coefficient=-2.0");
   console.log("urgency.user.tag.ready_for_beta.coefficient=-4.0");
   console.log("urgency.user.tag.in_beta.coefficient=-6.0");
-  if (fs2.existsSync(STANDARD_TIMEW_HOOK)) {
+  installTimewExtension();
+  if (fs4.existsSync(STANDARD_TIMEW_HOOK)) {
     console.log("\nTimewarrior hook detected. To enable tw-bridge time tracking:");
-    console.log("  tw-bridge timewarrior enable-overlaps");
+    console.log("  tw-bridge timewarrior enable");
   }
   installShellFunction();
 }
-var STANDARD_TIMEW_HOOK = path3.join(HOOKS_DIR, "on-modify.timewarrior");
+var TIMEW_EXT_DIR = path5.join(os4.homedir(), ".timewarrior", "extensions");
+function installTimewExtension() {
+  fs4.mkdirSync(TIMEW_EXT_DIR, { recursive: true });
+  const extSource = path5.resolve(
+    path5.dirname(new URL(import.meta.url).pathname),
+    "extensions",
+    "bridge.js"
+  );
+  const extTarget = path5.join(TIMEW_EXT_DIR, "bridge");
+  if (fs4.existsSync(extTarget)) {
+    fs4.unlinkSync(extTarget);
+  }
+  fs4.symlinkSync(extSource, extTarget);
+  fs4.chmodSync(extSource, 493);
+  console.log(`
+Installed Timewarrior extension: ${extTarget} -> ${extSource}`);
+  console.log("  Usage: timew bridge [task-time|wall-time] [project-filter]");
+}
+function sanitizeMeetingName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function detectProjectContext() {
+  const cwd = process.cwd();
+  const config = loadConfig();
+  for (const [, backend] of Object.entries(config.backends)) {
+    const backendCwd = backend.config?.cwd;
+    if (!backendCwd) continue;
+    const resolved = path5.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path5.sep)) {
+      return backend.match.tags?.[0] ?? null;
+    }
+  }
+  return null;
+}
+async function meetingCmd() {
+  const sub = process.argv[3];
+  if (!sub || sub === "--help") {
+    console.log("Usage: tw-bridge meeting <subcommand>\n");
+    console.log("Subcommands:");
+    console.log("  start <name> [--switch]  Start tracking a meeting");
+    console.log("  stop [name]              Stop a meeting (or all if no name)");
+    console.log("  list                     Show active meetings");
+    console.log("\nMeetings are tracked in Timewarrior only \u2014 no Taskwarrior task is created.");
+    console.log("By default, meetings run in parallel with active tasks.");
+    console.log("Use --switch to pause the current task instead.");
+    return;
+  }
+  const config = loadConfig();
+  if (!config.timewarrior?.enabled) {
+    console.error("Timewarrior is not enabled. Run: tw-bridge timewarrior enable");
+    process.exit(1);
+  }
+  if (sub === "start") {
+    const nameArg = process.argv.slice(4).filter((a) => !a.startsWith("--")).join(" ");
+    if (!nameArg) {
+      console.error("Usage: tw-bridge meeting start <name>");
+      process.exit(1);
+    }
+    const switchMode = process.argv.includes("--switch") || process.argv.includes("-s");
+    const tag = sanitizeMeetingName(nameArg);
+    const key = `meeting:${tag}`;
+    const tags = ["meeting", tag];
+    const project = detectProjectContext();
+    if (project) tags.push(project);
+    if (switchMode) {
+      startSwitch(key, tags);
+    } else {
+      startParallel(key, tags);
+    }
+    console.log(`Meeting started: ${nameArg}`);
+    console.log(`  Tags: ${tags.join(" ")}`);
+    if (!switchMode) {
+      console.log("  Mode: parallel (active tasks continue tracking)");
+    } else {
+      console.log("  Mode: switch (active tasks paused)");
+    }
+    return;
+  }
+  if (sub === "stop") {
+    const nameArg = process.argv.slice(4).join(" ").trim();
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    if (nameArg) {
+      const tag = sanitizeMeetingName(nameArg);
+      const key = `meeting:${tag}`;
+      const match = active.find((m) => m.key === key);
+      if (!match) {
+        console.error(`No active meeting matching "${nameArg}".`);
+        console.error(`Active meetings: ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+        process.exit(1);
+      }
+      stopEntry(key);
+      console.log(`Meeting stopped: ${nameArg}`);
+    } else {
+      for (const m of active) {
+        stopEntry(m.key);
+      }
+      console.log(`Stopped ${active.length} meeting(s): ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+    }
+    return;
+  }
+  if (sub === "list") {
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    console.log("Active meetings:");
+    for (const m of active) {
+      const name = m.key.replace("meeting:", "");
+      console.log(`  ${name}  (${m.tags.join(" ")})`);
+    }
+    return;
+  }
+  console.error(`Unknown subcommand: ${sub}`);
+  process.exit(1);
+}
+var STANDARD_TIMEW_HOOK = path5.join(HOOKS_DIR, "on-modify.timewarrior");
 async function timewarriorCmd() {
   const sub = process.argv[3];
   if (!sub || sub === "--help") {
     console.log("Usage: tw-bridge timewarrior <subcommand>\n");
     console.log("Subcommands:");
-    console.log("  enable           Enable Timewarrior tracking");
-    console.log("  enable-overlaps  Enable with overlapping intervals (for parallel work)");
-    console.log("  disable          Disable Timewarrior tracking");
-    console.log("  status           Show current Timewarrior configuration");
+    console.log("  enable   Enable Timewarrior tracking");
+    console.log("  disable  Disable Timewarrior tracking");
+    console.log("  status   Show current Timewarrior configuration");
+    console.log("\nParallel time tracking is controlled per-invocation:");
+    console.log("  task start <id> --parallel   Track in parallel with current task");
+    console.log("  task start <id> --switch     Stop current task, start new one");
     return;
   }
   const config = loadConfig();
@@ -419,10 +1028,11 @@ async function timewarriorCmd() {
     if (!tw?.enabled) {
       console.log("Timewarrior: disabled");
     } else {
-      console.log(`Timewarrior: enabled (overlaps: ${tw.allow_overlaps ? "yes" : "no"})`);
+      console.log("Timewarrior: enabled");
+      console.log("  Parallel tracking: use `task start <id> --parallel`");
     }
-    const hookExists = fs2.existsSync(STANDARD_TIMEW_HOOK);
-    const hookDisabled = fs2.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
+    const hookExists = fs4.existsSync(STANDARD_TIMEW_HOOK);
+    const hookDisabled = fs4.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
     if (hookExists) {
       console.log(`Standard hook: active (${STANDARD_TIMEW_HOOK})`);
       if (tw?.enabled) {
@@ -435,18 +1045,14 @@ async function timewarriorCmd() {
     }
     return;
   }
-  if (sub === "enable" || sub === "enable-overlaps") {
-    const allowOverlaps = sub === "enable-overlaps";
-    config.timewarrior = {
-      enabled: true,
-      allow_overlaps: allowOverlaps
-    };
+  if (sub === "enable") {
+    config.timewarrior = { enabled: true };
     const configPath = saveConfig(config);
-    console.log(`Timewarrior tracking enabled (overlaps: ${allowOverlaps ? "yes" : "no"})`);
+    console.log("Timewarrior tracking enabled");
     console.log(`Config: ${configPath}`);
-    if (fs2.existsSync(STANDARD_TIMEW_HOOK)) {
+    if (fs4.existsSync(STANDARD_TIMEW_HOOK)) {
       const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-      fs2.renameSync(STANDARD_TIMEW_HOOK, disabled);
+      fs4.renameSync(STANDARD_TIMEW_HOOK, disabled);
       console.log(`
 Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
       console.log("tw-bridge will handle Timewarrior tracking directly.");
@@ -454,16 +1060,13 @@ Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
     return;
   }
   if (sub === "disable") {
-    config.timewarrior = {
-      enabled: false,
-      allow_overlaps: false
-    };
+    config.timewarrior = { enabled: false };
     const configPath = saveConfig(config);
     console.log("Timewarrior tracking disabled");
     console.log(`Config: ${configPath}`);
     const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-    if (fs2.existsSync(disabled)) {
-      fs2.renameSync(disabled, STANDARD_TIMEW_HOOK);
+    if (fs4.existsSync(disabled)) {
+      fs4.renameSync(disabled, STANDARD_TIMEW_HOOK);
       console.log(`
 Restored standard hook: ${STANDARD_TIMEW_HOOK}`);
     }
@@ -475,40 +1078,46 @@ Restored standard hook: ${STANDARD_TIMEW_HOOK}`);
 var SHELL_FUNCTION = `
 # tw-bridge: auto-context task wrapper
 task() {
-  local ctx
+  local ctx mode=""
+  local args=()
+
+  for arg in "$@"; do
+    case "$arg" in
+      --parallel|-p) mode="parallel" ;;
+      --switch|-s)   mode="switch" ;;
+      *)             args+=("$arg") ;;
+    esac
+  done
+
   ctx=$(tw-bridge which 2>/dev/null)
-  if [ -n "$ctx" ]; then
-    command task "rc.context=$ctx" "$@"
-  else
-    command task "$@"
-  fi
+  TW_BRIDGE_MODE="$mode" command task \${ctx:+"rc.context=$ctx"} "\${args[@]}"
 }
 `.trim();
 var SHELL_MARKER = "# tw-bridge: auto-context task wrapper";
 function installShellFunction() {
   const shell = process.env.SHELL ?? "/bin/bash";
-  const home = os2.homedir();
+  const home = os4.homedir();
   let rcFile;
   if (shell.endsWith("zsh")) {
-    rcFile = path3.join(home, ".zshrc");
+    rcFile = path5.join(home, ".zshrc");
   } else {
-    rcFile = path3.join(home, ".bashrc");
+    rcFile = path5.join(home, ".bashrc");
   }
-  const existing = fs2.existsSync(rcFile) ? fs2.readFileSync(rcFile, "utf-8") : "";
+  const existing = fs4.existsSync(rcFile) ? fs4.readFileSync(rcFile, "utf-8") : "";
   if (existing.includes(SHELL_MARKER)) {
     console.log(`
 Shell integration already installed in ${rcFile}`);
     return;
   }
-  fs2.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
+  fs4.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
   console.log(`
 Shell integration installed in ${rcFile}`);
   console.log("Restart your shell or run: source " + rcFile);
 }
-var SEEN_FILE = path3.join(os2.homedir(), ".config", "tw-bridge", ".seen-dirs");
+var SEEN_FILE = path5.join(os4.homedir(), ".config", "tw-bridge", ".seen-dirs");
 function loadSeenDirs() {
   try {
-    const raw = fs2.readFileSync(SEEN_FILE, "utf-8");
+    const raw = fs4.readFileSync(SEEN_FILE, "utf-8");
     return new Set(raw.split("\n").filter(Boolean));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -518,15 +1127,15 @@ function markDirSeen(dir) {
   const seen = loadSeenDirs();
   if (seen.has(dir)) return;
   seen.add(dir);
-  fs2.mkdirSync(path3.dirname(SEEN_FILE), { recursive: true });
-  fs2.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
+  fs4.mkdirSync(path5.dirname(SEEN_FILE), { recursive: true });
+  fs4.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
 }
 function isGitRepo(dir) {
   try {
     let current = dir;
-    while (current !== path3.dirname(current)) {
-      if (fs2.existsSync(path3.join(current, ".git"))) return true;
-      current = path3.dirname(current);
+    while (current !== path5.dirname(current)) {
+      if (fs4.existsSync(path5.join(current, ".git"))) return true;
+      current = path5.dirname(current);
     }
     return false;
   } catch {
@@ -539,8 +1148,8 @@ async function which() {
   for (const [_name, backend] of Object.entries(config.backends)) {
     const backendCwd = backend.config?.cwd;
     if (!backendCwd) continue;
-    const resolved = path3.resolve(backendCwd);
-    if (cwd === resolved || cwd.startsWith(resolved + path3.sep)) {
+    const resolved = path5.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path5.sep)) {
       const contextTag = backend.match.tags?.[0];
       if (contextTag) {
         process.stdout.write(contextTag);
@@ -556,15 +1165,15 @@ async function which() {
     const seen = loadSeenDirs();
     let gitRoot = cwd;
     let current = cwd;
-    while (current !== path3.dirname(current)) {
-      if (fs2.existsSync(path3.join(current, ".git"))) {
+    while (current !== path5.dirname(current)) {
+      if (fs4.existsSync(path5.join(current, ".git"))) {
         gitRoot = current;
         break;
       }
-      current = path3.dirname(current);
+      current = path5.dirname(current);
     }
     if (!seen.has(gitRoot)) {
-      const dirName = path3.basename(gitRoot);
+      const dirName = path5.basename(gitRoot);
       process.stderr.write(
         `tw-bridge: unconfigured project "${dirName}". Run: tw-bridge add ${dirName} --adapter ghp
 `
@@ -628,6 +1237,14 @@ async function syncBackend(name, backend, config) {
       }
     } else if (isDone) {
       if (completeTask(existingTask, matchTags)) {
+        if (adapter.onDone) {
+          try {
+            await adapter.onDone(task);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`  \u26A0 [#${backendId}] failed to push completion: ${msg}`);
+          }
+        }
         console.log(`  \u2713 [#${backendId}] ${task.description}`);
         completed++;
       }