@corners/cli 0.0.5 → 0.0.7

package/dist/cli.js

@@ -1,12 +1,38 @@
-import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { readFile, realpath, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { basename, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { CornersApiClient as DefaultCornersApiClient, } from "./client.js";
 import { ConfigStore, LOCAL_ROOT_CONFIG_RELATIVE_PATH, } from "./config.js";
 import { buildExpectedManagedGuidanceBlock, buildGuidanceFileContent, buildGuidanceRevision, extractManagedGuidanceBlock, GUIDANCE_SYNC_COMMAND, GUIDANCE_TARGETS, normalizeGuidanceTargets, } from "./guidance.js";
 import { createPromptApi } from "./prompts.js";
-import { CLIError, getPackageVersion, normalizeApiUrl, openUrlInBrowser, printJson, printLine, readTextFromStdin, sleep, toGraphQLAttachmentKind, toGraphQLWorkstreamStatus, toGraphQLWorkstreamUpdateType, toIsoString, } from "./support.js";
+import { BUNDLED_SKILLS, buildInstalledSkillReferences, buildSkillPlannedEdits, getBundledSkillPath, parseSkillFrontmatter, resolveSkillsState, syncSkillsIfNeeded, withUpdatedSkillsConfig, } from "./skills.js";
+import { buildPlannedEdit, CLIError, getPackageVersion, normalizeApiUrl, openUrlInBrowser, printJson, printLine, readOptionalUtf8, readTextFromStdin, sleep, toGraphQLAttachmentKind, toGraphQLWorkstreamStatus, toGraphQLWorkstreamUpdateType, toIsoString, writePlannedEdits, } from "./support.js";
+const WORKSTREAM_LIST_QUERY = `
+  query CliWorkstreamList($first: Int!, $filter: WorkstreamsFilter) {
+    workstreams(first: $first, filter: $filter) {
+      edges {
+        node {
+          id
+          accountId
+          cornerId
+          name
+          isOpen
+          summary
+          category
+          status
+          statusDetails
+          updatedAt
+          topic {
+            id
+            name
+          }
+        }
+      }
+      totalCount
+    }
+  }
+`;
 const WORKSTREAM_LOOKUP_QUERY = `
   query CliWorkstreamLookup($id: ID!) {
     workstream(id: $id) {
@@ -128,6 +154,24 @@ const WORKSTREAM_PULL_QUERY = `
                 updatedAt
               }
             }
+            ... on WorkstreamTodoListAttachment {
+              todoList {
+                id
+                title
+                openItemCount
+                totalItemCount
+                items {
+                  id
+                  title
+                  completed
+                  itemIndex
+                  assignee {
+                    id
+                    handle
+                  }
+                }
+              }
+            }
           }
         }
       }
@@ -308,6 +352,71 @@ const UPDATE_WORKSTREAM_MUTATION = `
     }
   }
 `;
+const WORKSTREAM_TASK_LIST_QUERY = `
+  query CliWorkstreamTasks($id: ID!, $attachmentsFirst: Int!) {
+    workstream(id: $id) {
+      id
+      name
+      attachments(first: $attachmentsFirst, kind: TODOLIST) {
+        edges {
+          node {
+            __typename
+            ... on WorkstreamTodoListAttachment {
+              todoList {
+                id
+                title
+                openItemCount
+                totalItemCount
+                items {
+                  id
+                  title
+                  description
+                  completed
+                  completedAt
+                  itemIndex
+                  assignee {
+                    id
+                    handle
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const CREATE_TODO_LIST_MUTATION = `
+  mutation CliCreateTodoList($input: CreateTodoListInput!) {
+    createTodoList(input: $input) {
+      id
+      title
+      openItemCount
+      totalItemCount
+    }
+  }
+`;
+const ADD_TODO_ITEM_MUTATION = `
+  mutation CliAddTodoItem($input: AddTodoItemInput!) {
+    addTodoItem(input: $input) {
+      id
+      title
+      completed
+      itemIndex
+    }
+  }
+`;
+const TOGGLE_TODO_ITEM_MUTATION = `
+  mutation CliToggleTodoItem($id: ID!, $completed: Boolean!) {
+    toggleTodoItem(id: $id, completed: $completed) {
+      id
+      title
+      completed
+      completedAt
+    }
+  }
+`;
 const REVOKE_MCP_SESSION_MUTATION = `
   mutation CliRevokeMcpSession($id: ID!) {
     revokeMCPSession(id: $id)
@@ -379,6 +488,7 @@ function printMainHelp(runtime) {
         "Commands:",
         "  auth login|logout|status",
         "  guidance status|sync",
+        "  skills list|status",
         "  init",
         "  corner use",
         "  whoami",
@@ -403,6 +513,17 @@ function printInitHelp(runtime) {
         "  corners init [--profile <name>] [--api-url <url>] [--json]",
     ].join("\n"));
 }
+function printSkillsHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners skills",
+        "",
+        "Usage:",
+        "  corners skills list [--json]      List bundled skills",
+        "  corners skills status [--json]    Show installed skill state",
+        "",
+        "Skills are auto-synced on every CLI run once enabled via `corners init`.",
+    ].join("\n"));
+}
 function printGuidanceHelp(runtime) {
     printLine(runtime.stdout, [
         "corners guidance",
@@ -443,18 +564,24 @@ function printWorkstreamHelp(runtime) {
         "corners workstream",
         "",
         "Usage:",
-        "  corners workstream list [--json]",
+        "  corners workstream list [--all] [--json]",
         "  corners workstream use <workstreamId> [--json]",
         "  corners workstream current [--json]",
         "  corners workstream create <name> [--summary <text>] [--corner <cornerNameOrId>] [--json]",
-        "  corners workstream pull <workstreamId> [--json]",
-        "  corners workstream update <workstreamId> [--status <status>] [--status-details <text> | --clear-status-details] [--json]",
-        "  corners workstream push <workstreamId> [--type <type>] [--message <text>] [--summary <text>] [--file <path>] [--title <title>] [--json]",
-        "  corners workstream question list <workstreamId> [--json]",
-        "  corners workstream question ask <workstreamId> [--question <text>] [--rationale <text>] [--suggested-answer <text>]... [--json]",
+        "  corners workstream pull [-w <id>] [--json]",
+        "  corners workstream update [-w <id>] [--status <status>] [--status-details <text> | --clear-status-details] [--json]",
+        "  corners workstream push [-w <id>] [--type <type>] [--message <text>] [--summary <text>] [--file <path>] [--title <title>] [--json]",
+        "  corners workstream question list [-w <id>] [--json]",
+        "  corners workstream question ask [-w <id>] [--question <text>] [--rationale <text>] [--suggested-answer <text>]... [--json]",
         "  corners workstream question answer <questionId> [--text <text>] [--json]",
-        "  corners workstream attach <workstreamId> --kind <kind> --entity-id <id> [--json]",
+        "  corners workstream attach [-w <id>] --kind <kind> --entity-id <id> [--json]",
         "  corners workstream reply-thread <threadId> [--text <text>] [--json]",
+        "  corners workstream task list [-w <id>] [--json]",
+        "  corners workstream task add [-w <id>] <title> [--list <todoListId>] [--json]",
+        "  corners workstream task complete <taskItemId> [--undo] [--json]",
+        "",
+        "The -w/--workstream flag is optional when an active workstream is set.",
+        "Set the active workstream with: corners workstream use <workstreamId>",
         "",
         "Lifecycle statuses:",
         "  scoping | in_progress | blocked | done",
@@ -672,17 +799,6 @@ async function withPrompts(runtime, run) {
         await prompts.close();
     }
 }
-async function readOptionalUtf8(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
 function ensureTrailingNewline(value) {
     return value.endsWith("\n") ? value : `${value}\n`;
 }
@@ -818,6 +934,7 @@ async function resolveRootContext(runtime, common, root, options) {
             printLine(runtime.stderr, warning);
         }
     }
+    await syncSkillsIfNeeded(root.rootDir, root.config, (dir, cfg) => runtime.config.writeLocalConfig(dir, cfg));
     return {
         root,
         guidance,
@@ -904,6 +1021,16 @@ async function resolveExplicitWorkstream(client, common, workstreamId) {
     }
     return data.workstream;
 }
+async function resolveWorkstreamId(runtime, common, flagValue) {
+    if (flagValue) {
+        return flagValue;
+    }
+    const binding = await runtime.config.getBinding(runtime.cwd);
+    if (binding) {
+        return binding.workstreamId;
+    }
+    throw new CLIError("No --workstream flag and no active workstream. Use `corners workstream use <id>` first.", { json: common.json });
+}
 function connectWorkstream(config, workstreamId) {
     if (config.connectedWorkstreams.some((entry) => entry.id === workstreamId)) {
         return config;
@@ -939,17 +1066,6 @@ function upsertCornerOverride(config, relativePath, corner) {
         cornerOverrides: overrides,
     };
 }
-async function buildPlannedEdit(path, nextContent) {
-    const existing = await readOptionalUtf8(path);
-    if (existing === nextContent) {
-        return null;
-    }
-    return {
-        path,
-        action: existing === null ? "create" : "update",
-        content: nextContent,
-    };
-}
 function withUpdatedGuidanceConfig(config, managedTargets, syncedAt) {
     return {
         ...config,
@@ -977,12 +1093,6 @@ function ensureGitignoreEntry(existing) {
     }
     return `${trimmed}\n${LOCAL_ROOT_CONFIG_RELATIVE_PATH}\n`;
 }
-async function writePlannedEdits(edits) {
-    for (const edit of edits) {
-        await mkdir(dirname(edit.path), { recursive: true });
-        await writeFile(edit.path, edit.content, "utf8");
-    }
-}
 function formatWorkstreamLine(workstream) {
     return [
         workstream.id,
@@ -1304,6 +1414,7 @@ async function handleInit(args, runtime, inherited) {
                 selectedTargets.push(target);
             }
         }
+        const installSkills = await prompts.confirm("Install Corners skills? (sync, push, ask, plan)", { defaultValue: true });
         const selectedCornerId = await prompts.select("Choose the default corner for this local root.", joinedCorners.map((corner) => ({
             label: `${corner.name} (${corner.id})`,
             value: corner.id,
@@ -1313,7 +1424,7 @@ async function handleInit(args, runtime, inherited) {
         const defaultCorner = joinedCorners.find((corner) => corner.id === selectedCornerId) ??
             joinedCorners[0];
         const syncedAt = toIsoString();
-        const nextLocalConfig = withUpdatedGuidanceConfig({
+        let nextLocalConfig = withUpdatedGuidanceConfig({
             version: 1,
             profile: profileName,
             workspace: profile.workspace,
@@ -1325,6 +1436,10 @@ async function handleInit(args, runtime, inherited) {
             cornerOverrides: existingConfig?.cornerOverrides ?? [],
             connectedWorkstreams: existingConfig?.connectedWorkstreams ?? [],
         }, selectedTargets.map((target) => target.key), syncedAt);
+        if (installSkills) {
+            const skillRefs = await buildInstalledSkillReferences(syncedAt);
+            nextLocalConfig = withUpdatedSkillsConfig(nextLocalConfig, skillRefs, syncedAt);
+        }
         const plannedEdits = [];
         const gitignorePath = join(rootDir, ".gitignore");
         const gitignoreContent = ensureGitignoreEntry(await readOptionalUtf8(gitignorePath));
@@ -1345,6 +1460,10 @@ async function handleInit(args, runtime, inherited) {
                 plannedEdits.push(edit);
             }
         }
+        if (installSkills) {
+            const skillEdits = await buildSkillPlannedEdits(rootDir);
+            plannedEdits.push(...skillEdits);
+        }
         if (plannedEdits.length > 0 && !common.json) {
             printLine(runtime.stderr, [
                 "Planned changes:",
@@ -1370,12 +1489,96 @@ async function handleInit(args, runtime, inherited) {
             }
             await writePlannedEdits(plannedEdits);
         }
+        // --- Agent Communication Setup ---
+        const setupAgentComms = await prompts.confirm("Set up agent communication? (auto-connect workstream + CLAUDE.md instructions)", { defaultValue: true });
+        let connectedWorkstream = null;
+        if (setupAgentComms) {
+            // Auto-connect or create a workstream
+            const workstreams = await client.graphql(`query CliInitWorkstreams($cornerId: ID!) {
+          corner(id: $cornerId) { workstreams(first: 20) { edges { node { id name status } } } }
+        }`, { cornerId: defaultCorner.id }).then((r) => {
+                const corner = r.corner;
+                return corner?.workstreams?.edges?.map((e) => e.node) ?? [];
+            }).catch(() => []);
+            if (workstreams.length > 0) {
+                const wsChoice = await prompts.select("Connect a workstream for agent updates:", [
+                    ...workstreams.map((ws) => ({
+                        label: `${ws.name} (${ws.id})`,
+                        value: ws.id,
+                    })),
+                    { label: "Create new workstream", value: "__new__" },
+                    { label: "Skip", value: "__skip__" },
+                ], { defaultValue: workstreams[0]?.id });
+                if (wsChoice === "__new__") {
+                    const wsName = `agent/${basename(rootDir)}`;
+                    const created = await client.graphql(`mutation CliCreateWsInit($input: CreateWorkstreamInput!) { createWorkstream(input: $input) { id name } }`, { input: { cornerId: defaultCorner.id, name: wsName } });
+                    connectedWorkstream = created.createWorkstream;
+                }
+                else if (wsChoice !== "__skip__") {
+                    connectedWorkstream = workstreams.find((ws) => ws.id === wsChoice) ?? null;
+                }
+            }
+            else {
+                const wsName = `agent/${basename(rootDir)}`;
+                const created = await client.graphql(`mutation CliCreateWsInit($input: CreateWorkstreamInput!) { createWorkstream(input: $input) { id name } }`, { input: { cornerId: defaultCorner.id, name: wsName } });
+                connectedWorkstream = created.createWorkstream;
+            }
+            // Connect workstream to local root
+            if (connectedWorkstream) {
+                nextLocalConfig = {
+                    ...nextLocalConfig,
+                    connectedWorkstreams: [
+                        ...(nextLocalConfig.connectedWorkstreams ?? []),
+                        { id: connectedWorkstream.id, connectedAt: toIsoString() },
+                    ],
+                };
+                // Re-write the local config with the connected workstream
+                const updatedConfigPath = runtime.config.getLocalConfigPath(rootDir);
+                await writeFile(updatedConfigPath, `${JSON.stringify(nextLocalConfig, null, 2)}\n`, "utf8");
+            }
+            // Write CLAUDE.md agent instructions
+            const claudeMdPath = join(rootDir, "CLAUDE.md");
+            const existingClaudeMd = await readOptionalUtf8(claudeMdPath);
+            const agentSection = `\n## Agent Communication\n\nWhen working on tasks, report progress to the team through Corners:\n- At the start: \`corners workstream push --type session_start --intent "description" --json\`\n- At natural checkpoints: \`corners workstream push --type checkpoint --message "what you did" --files "file1,file2" --json\`\n- When done: \`corners workstream push --type session_end --summary "what was accomplished" --json\`\n`;
+            if (existingClaudeMd && !existingClaudeMd.includes("## Agent Communication")) {
+                await writeFile(claudeMdPath, existingClaudeMd + agentSection, "utf8");
+                if (!common.json) {
+                    printLine(runtime.stderr, "  Added agent communication instructions to CLAUDE.md");
+                }
+            }
+            else if (!existingClaudeMd) {
+                await writeFile(claudeMdPath, `# ${basename(rootDir)}\n${agentSection}`, "utf8");
+                if (!common.json) {
+                    printLine(runtime.stderr, "  Created CLAUDE.md with agent communication instructions");
+                }
+            }
+            // Send test checkpoint
+            if (connectedWorkstream) {
+                try {
+                    await client.graphql(RECORD_WORKSTREAM_UPDATE_MUTATION, {
+                        input: {
+                            workstreamId: connectedWorkstream.id,
+                            updateType: "CHECKPOINT",
+                            content: "Agent communication configured via corners init",
+                            agentType: "corners-cli",
+                        },
+                    });
+                    if (!common.json) {
+                        printLine(runtime.stderr, `  Test checkpoint sent to ${connectedWorkstream.name}`);
+                    }
+                }
+                catch {
+                    // Non-critical, don't fail init
+                }
+            }
+        }
         const payload = {
             ok: true,
             root: rootDir,
             profile: profileName,
             workspace: profile.workspace,
             defaultCorner,
+            connectedWorkstream,
             files: plannedEdits.map((edit) => ({
                 action: edit.action,
                 path: relative(rootDir, edit.path) || ".",
@@ -1385,11 +1588,108 @@ async function handleInit(args, runtime, inherited) {
             printJson(runtime.stdout, payload);
         }
         else {
-            printLine(runtime.stdout, `Initialized Corners CLI at ${rootDir} with default corner ${defaultCorner.name}. Run \`${GUIDANCE_SYNC_COMMAND}\` later to refresh managed guidance.`);
+            const wsMsg = connectedWorkstream
+                ? ` Connected workstream: ${connectedWorkstream.name}.`
+                : "";
+            printLine(runtime.stdout, `Initialized Corners CLI at ${rootDir} with default corner ${defaultCorner.name}.${wsMsg} Run \`${GUIDANCE_SYNC_COMMAND}\` later to refresh managed guidance.`);
         }
         return 0;
     });
 }
+async function handleSkills(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printSkillsHelp(runtime);
+        return 0;
+    }
+    switch (subcommand) {
+        case "list": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+            });
+            if (parsed.values.help) {
+                printSkillsHelp(runtime);
+                return 0;
+            }
+            const skills = await Promise.all(BUNDLED_SKILLS.map(async (skill) => {
+                const content = await readFile(getBundledSkillPath(skill), "utf8");
+                const fm = parseSkillFrontmatter(content);
+                return {
+                    name: skill.name,
+                    version: fm?.version ?? "unknown",
+                    description: fm?.description ?? "",
+                };
+            }));
+            if (common.json) {
+                printJson(runtime.stdout, { ok: true, skills });
+            }
+            else {
+                printLine(runtime.stdout, [
+                    "Available skills:",
+                    ...skills.map((s) => `  ${s.name.padEnd(16)} ${s.version.padEnd(8)} ${s.description}`),
+                ].join("\n"));
+            }
+            return 0;
+        }
+        case "status": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: false,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+            });
+            if (parsed.values.help) {
+                printSkillsHelp(runtime);
+                return 0;
+            }
+            const rootContext = await requireLocalRoot(runtime, common, {
+                emitWarning: false,
+            });
+            const state = await resolveSkillsState(rootContext.root.rootDir, rootContext.root.config);
+            const payload = {
+                ok: true,
+                root: rootContext.root.rootDir,
+                skills: state,
+            };
+            if (common.json) {
+                printJson(runtime.stdout, payload);
+            }
+            else {
+                printLine(runtime.stdout, [
+                    `Root: ${payload.root}`,
+                    `Last synced: ${state.lastSyncedAt ?? "-"}`,
+                    "",
+                    "Skills:",
+                    ...state.skills.map((s) => {
+                        const stateLabel = s.state.padEnd(8);
+                        const version = s.state === "stale"
+                            ? `(installed: ${s.installedVersion}, available: ${s.bundledVersion})`
+                            : s.state === "missing"
+                                ? ""
+                                : `(${s.bundledVersion})`;
+                        return `  ${s.name.padEnd(16)} ${stateLabel} ${version}`;
+                    }),
+                ].join("\n"));
+            }
+            return 0;
+        }
+        default:
+            throw new CLIError(`Unknown skills command: ${subcommand}`);
+    }
+}
 async function handleGuidance(args, runtime, inherited) {
     const subcommand = args[0];
     if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -1587,6 +1887,7 @@ async function handleWorkstream(args, runtime, inherited) {
                     help: { type: "boolean", short: "h" },
                     profile: { type: "string" },
                     "api-url": { type: "string" },
+                    all: { type: "boolean" },
                 },
             });
             const common = mergeCommonOptions(inherited, {
@@ -1598,44 +1899,41 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const rootContext = await requireLocalRoot(runtime, common);
-            const { root, guidance, client } = await requirePinnedRootProfile(runtime, common, rootContext);
-            const hydrated = await Promise.all(root.config.connectedWorkstreams.map(async (entry) => {
-                try {
-                    return {
-                        entry,
-                        workstream: await resolveExplicitWorkstream(client, common, entry.id),
-                    };
-                }
-                catch {
-                    return {
-                        entry,
-                        workstream: null,
-                    };
-                }
-            }));
-            const workstreams = hydrated
-                .filter((entry) => entry.workstream !== null)
-                .map((entry) => entry.workstream);
-            const missingWorkstreamIds = hydrated
-                .filter((entry) => entry.workstream === null)
-                .map((entry) => entry.entry.id);
+            const { guidance, client } = await requireCommandProfile(runtime, common);
+            const filter = {};
+            if (!parsed.values.all) {
+                filter.isOpen = true;
+            }
+            const data = await client.graphql(WORKSTREAM_LIST_QUERY, { first: 100, filter });
+            const allWorkstreams = data.workstreams.edges.map((edge) => edge.node);
+            const totalCount = data.workstreams.totalCount;
+            // Try to find local root for connected workstream annotation
+            const root = await runtime.config.findLocalRoot(runtime.cwd);
+            const connectedIds = new Set(root?.config.connectedWorkstreams.map((entry) => entry.id) ?? []);
             if (common.json) {
                 printJson(runtime.stdout, withGuidanceJsonMetadata({
-                    root: root.rootDir,
-                    workstreams,
-                    missingWorkstreamIds,
+                    workstreams: allWorkstreams.map((ws) => ({
+                        ...ws,
+                        connected: connectedIds.has(ws.id),
+                    })),
+                    totalCount,
                 }, guidance));
             }
             else {
-                if (missingWorkstreamIds.length > 0) {
-                    printLine(runtime.stderr, missingWorkstreamIds
-                        .map((workstreamId) => `Warning: connected workstream ${workstreamId} is missing or inaccessible.`)
+                if (allWorkstreams.length === 0) {
+                    printLine(runtime.stdout, "No workstreams found.");
+                }
+                else {
+                    printLine(runtime.stdout, allWorkstreams
+                        .map((ws) => {
+                        const prefix = connectedIds.has(ws.id) ? "* " : "  ";
+                        return `${prefix}${formatWorkstreamLine(ws)}`;
+                    })
                         .join("\n"));
+                    if (totalCount > 100) {
+                        printLine(runtime.stderr, `Showing 100 of ${totalCount} workstreams.`);
+                    }
                 }
-                printLine(runtime.stdout, workstreams.length > 0
-                    ? workstreams.map(formatWorkstreamLine).join("\n")
-                    : "No workstreams are connected to this local environment.");
             }
             return 0;
         }
@@ -1672,15 +1970,23 @@ async function handleWorkstream(args, runtime, inherited) {
             if (nextConfig !== root.config) {
                 await runtime.config.writeLocalConfig(root.rootDir, nextConfig);
             }
+            await runtime.config.setBinding(runtime.cwd, {
+                profile: root.config.profile,
+                workspace: root.config.workspace ?? "",
+                workstreamId: workstream.id,
+                cornerId: workstream.cornerId,
+                boundAt: toIsoString(),
+            });
             if (common.json) {
                 printJson(runtime.stdout, withGuidanceJsonMetadata({
                     ok: true,
                     root: root.rootDir,
                     workstream,
+                    bound: true,
                 }, guidance));
             }
             else {
-                printLine(runtime.stdout, `Connected ${workstream.id} (${workstream.name}) to ${root.rootDir}.`);
+                printLine(runtime.stdout, `Connected ${workstream.id} (${workstream.name}) to ${root.rootDir} and set as active workstream.`);
             }
             return 0;
         }
@@ -1703,12 +2009,14 @@ async function handleWorkstream(args, runtime, inherited) {
             const { root, guidance } = await requireLocalRoot(runtime, common);
             const cwdPath = await realpath(runtime.cwd);
             const resolvedCorner = resolveCornerForCwd(root, cwdPath);
+            const binding = await runtime.config.getBinding(runtime.cwd);
             const payload = {
                 cwd: runtime.cwd,
                 root: root.rootDir,
                 profile: root.config.profile,
                 workspace: root.config.workspace,
                 resolvedCorner,
+                activeWorkstreamId: binding?.workstreamId ?? null,
                 connectedWorkstreamIds: root.config.connectedWorkstreams.map((entry) => entry.id),
             };
             if (common.json) {
@@ -1721,6 +2029,7 @@ async function handleWorkstream(args, runtime, inherited) {
                     `Profile: ${payload.profile}`,
                     `Workspace: ${payload.workspace ?? "-"}`,
                     `Resolved corner: ${payload.resolvedCorner.corner.name} (${payload.resolvedCorner.corner.id})`,
+                    `Active workstream: ${payload.activeWorkstreamId ?? "none"}`,
                     `Connected workstreams: ${payload.connectedWorkstreamIds.length}`,
                 ].join("\n"));
             }
@@ -1785,12 +2094,13 @@ async function handleWorkstream(args, runtime, inherited) {
         case "pull": {
             const parsed = parseArgs({
                 args: args.slice(1),
-                allowPositionals: true,
+                allowPositionals: false,
                 options: {
                     json: { type: "boolean" },
                     help: { type: "boolean", short: "h" },
                     profile: { type: "string" },
                     "api-url": { type: "string" },
+                    workstream: { type: "string", short: "w" },
                 },
             });
             const common = mergeCommonOptions(inherited, {
@@ -1802,12 +2112,7 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const workstreamId = parsed.positionals[0];
-            if (!workstreamId) {
-                throw new CLIError("Usage: corners workstream pull <workstreamId>", {
-                    json: common.json,
-                });
-            }
+            const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
             const { guidance, client } = await requireCommandProfile(runtime, common);
             const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             const data = await client.graphql(WORKSTREAM_PULL_QUERY, {
@@ -1820,7 +2125,7 @@ async function handleWorkstream(args, runtime, inherited) {
             }
             else {
                 const snapshot = data.workstream;
-                printLine(runtime.stdout, [
+                const lines = [
                     `${snapshot.name} (${snapshot.id})`,
                     snapshot.summary ? `Summary: ${snapshot.summary}` : "Summary: -",
                     `State: ${snapshot.isOpen === false ? "archived" : "open"}`,
@@ -1830,19 +2135,41 @@ async function handleWorkstream(args, runtime, inherited) {
                     `Answered questions: ${snapshot.answeredQuestions?.length ?? 0}`,
                     `Attachments: ${snapshot.attachments?.totalCount ?? 0}`,
                     `Feed items returned: ${snapshot.feed?.totalCount ?? 0}`,
-                ].join("\n"));
+                ];
+                // Append tasks from TodoList attachments
+                const todoLists = (snapshot.attachments?.edges ?? []).flatMap((e) => e.node.__typename === "WorkstreamTodoListAttachment" &&
+                    e.node.todoList
+                    ? [e.node.todoList]
+                    : []);
+                if (todoLists.length > 0) {
+                    lines.push("");
+                    lines.push("Tasks:");
+                    for (const list of todoLists) {
+                        const completed = list.totalItemCount - list.openItemCount;
+                        lines.push(`  ${list.title} (${completed}/${list.totalItemCount} complete)`);
+                        for (const item of list.items) {
+                            const check = item.completed ? "[x]" : "[ ]";
+                            const assignee = item.assignee
+                                ? ` (@${item.assignee.handle})`
+                                : "";
+                            lines.push(`    ${check} ${item.title}${assignee}`);
+                        }
+                    }
+                }
+                printLine(runtime.stdout, lines.join("\n"));
             }
             return 0;
         }
         case "update": {
             const parsed = parseArgs({
                 args: args.slice(1),
-                allowPositionals: true,
+                allowPositionals: false,
                 options: {
                     json: { type: "boolean" },
                     help: { type: "boolean", short: "h" },
                     profile: { type: "string" },
                     "api-url": { type: "string" },
+                    workstream: { type: "string", short: "w" },
                     status: { type: "string" },
                     "status-details": { type: "string" },
                     "clear-status-details": { type: "boolean" },
@@ -1857,10 +2184,6 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const workstreamId = parsed.positionals[0];
-            if (!workstreamId) {
-                throw new CLIError("Usage: corners workstream update <workstreamId> [--status <status>] [--status-details <text> | --clear-status-details]", { json: common.json });
-            }
             const rawStatusDetails = parsed.values["status-details"];
             const clearStatusDetails = parsed.values["clear-status-details"] === true;
             if (rawStatusDetails !== undefined && clearStatusDetails) {
@@ -1871,6 +2194,7 @@ async function handleWorkstream(args, runtime, inherited) {
                 !clearStatusDetails) {
                 throw new CLIError("Provide --status, --status-details, or --clear-status-details.", { json: common.json });
             }
+            const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
             const { guidance, client } = await requireCommandProfile(runtime, common);
             const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             const result = await client.graphql(UPDATE_WORKSTREAM_MUTATION, {
@@ -1912,11 +2236,16 @@ async function handleWorkstream(args, runtime, inherited) {
                     help: { type: "boolean", short: "h" },
                     profile: { type: "string" },
                     "api-url": { type: "string" },
+                    workstream: { type: "string", short: "w" },
                     type: { type: "string" },
                     message: { type: "string" },
                     summary: { type: "string" },
                     file: { type: "string" },
                     title: { type: "string" },
+                    "agent-type": { type: "string" },
+                    files: { type: "string" },
+                    scope: { type: "string" },
+                    intent: { type: "string" },
                 },
             });
             const common = mergeCommonOptions(inherited, {
@@ -1928,15 +2257,10 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const workstreamId = parsed.positionals[0];
-            if (!workstreamId) {
-                throw new CLIError("Usage: corners workstream push <workstreamId>", {
-                    json: common.json,
-                });
-            }
+            const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
             const message = parsed.values.message ??
-                (parsed.positionals.length > 1
-                    ? parsed.positionals.slice(1).join(" ")
+                (parsed.positionals.length > 0
+                    ? parsed.positionals.join(" ")
                     : await readTextFromStdin(runtime.stdin));
             if (!message) {
                 throw new CLIError("Workstream updates need a message. Use --message or pipe text on stdin.", { json: common.json });
@@ -1956,18 +2280,38 @@ async function handleWorkstream(args, runtime, inherited) {
                 });
                 createdDocument = documentResult.createDocument;
             }
+            // Parse agent-specific fields
+            const agentType = parsed.values["agent-type"] ??
+                (process.env.CLAUDE_CODE ? "claude-code" : null) ??
+                (process.env.CODEX_SESSION ? "codex" : null) ??
+                null;
+            const filesTouched = parsed.values.files
+                ? parsed.values.files.split(",").map((f) => f.trim())
+                : null;
+            const scope = parsed.values.scope ?? null;
+            // For session_start, --intent is an alias for --message
+            const updateType = parsed.values.type ?? "status";
+            const effectiveContent = updateType === "session_start" && parsed.values.intent
+                ? parsed.values.intent
+                : message;
             const updateResult = await client.graphql(RECORD_WORKSTREAM_UPDATE_MUTATION, {
                 input: {
                     workstreamId: workstream.id,
-                    updateType: toGraphQLWorkstreamUpdateType(parsed.values.type ?? "status"),
-                    content: message,
+                    updateType: toGraphQLWorkstreamUpdateType(updateType),
+                    content: effectiveContent,
                     summary: parsed.values.summary,
                     documentId: createdDocument?.id ?? null,
+                    ...(agentType ? { agentType } : {}),
+                    ...(filesTouched ? { filesTouched } : {}),
+                    ...(scope ? { scope } : {}),
                 },
             });
             const payload = {
                 ok: true,
+                success: true,
                 workstreamId: workstream.id,
+                type: updateType,
+                messageId: updateResult.recordWorkstreamUpdate.id,
                 update: updateResult.recordWorkstreamUpdate,
                 document: createdDocument,
             };
@@ -1989,12 +2333,13 @@ async function handleWorkstream(args, runtime, inherited) {
                 case "list": {
                     const parsed = parseArgs({
                         args: args.slice(2),
-                        allowPositionals: true,
+                        allowPositionals: false,
                         options: {
                             json: { type: "boolean" },
                             help: { type: "boolean", short: "h" },
                             profile: { type: "string" },
                             "api-url": { type: "string" },
+                            workstream: { type: "string", short: "w" },
                         },
                     });
                     const common = mergeCommonOptions(inherited, {
@@ -2006,10 +2351,7 @@ async function handleWorkstream(args, runtime, inherited) {
                         printWorkstreamHelp(runtime);
                         return 0;
                     }
-                    const workstreamId = parsed.positionals[0];
-                    if (!workstreamId) {
-                        throw new CLIError("Usage: corners workstream question list <workstreamId>", { json: common.json });
-                    }
+                    const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
                     const { guidance, client } = await requireCommandProfile(runtime, common);
                     const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
                     const data = await client.graphql(WORKSTREAM_QUESTION_LIST_QUERY, {
@@ -2040,6 +2382,7 @@ async function handleWorkstream(args, runtime, inherited) {
                             help: { type: "boolean", short: "h" },
                             profile: { type: "string" },
                             "api-url": { type: "string" },
+                            workstream: { type: "string", short: "w" },
                             question: { type: "string" },
                             rationale: { type: "string" },
                             "suggested-answer": { type: "string", multiple: true },
@@ -2054,13 +2397,10 @@ async function handleWorkstream(args, runtime, inherited) {
                         printWorkstreamHelp(runtime);
                         return 0;
                     }
-                    const workstreamId = parsed.positionals[0];
-                    if (!workstreamId) {
-                        throw new CLIError("Usage: corners workstream question ask <workstreamId> [--question <text>]", { json: common.json });
-                    }
+                    const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
                     const question = parsed.values.question ??
-                        (parsed.positionals.length > 1
-                            ? parsed.positionals.slice(1).join(" ")
+                        (parsed.positionals.length > 0
+                            ? parsed.positionals.join(" ")
                             : await readTextFromStdin(runtime.stdin));
                     if (!question) {
                         throw new CLIError("Question text is required. Use --question or pipe text on stdin.", { json: common.json });
@@ -2137,12 +2477,13 @@ async function handleWorkstream(args, runtime, inherited) {
         case "attach": {
             const parsed = parseArgs({
                 args: args.slice(1),
-                allowPositionals: true,
+                allowPositionals: false,
                 options: {
                     json: { type: "boolean" },
                     help: { type: "boolean", short: "h" },
                     profile: { type: "string" },
                     "api-url": { type: "string" },
+                    workstream: { type: "string", short: "w" },
                     kind: { type: "string" },
                     "entity-id": { type: "string" },
                 },
@@ -2156,12 +2497,12 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const workstreamId = parsed.positionals[0];
             const kind = parsed.values.kind;
             const entityId = parsed.values["entity-id"];
-            if (!workstreamId || !kind || !entityId) {
-                throw new CLIError("Usage: corners workstream attach <workstreamId> --kind <kind> --entity-id <id>", { json: common.json });
+            if (!kind || !entityId) {
+                throw new CLIError("Usage: corners workstream attach [--workstream <id>] --kind <kind> --entity-id <id>", { json: common.json });
             }
+            const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
             const { guidance, client } = await requireCommandProfile(runtime, common);
             const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             const result = await client.graphql(ADD_WORKSTREAM_ATTACHMENT_MUTATION, {
@@ -2221,10 +2562,241 @@ async function handleWorkstream(args, runtime, inherited) {
             }
             return 0;
         }
+        case "task": {
+            const nested = args[1];
+            if (!nested || nested === "help" || nested === "--help") {
+                printWorkstreamHelp(runtime);
+                return 0;
+            }
+            switch (nested) {
+                case "list": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: false,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                            workstream: { type: "string", short: "w" },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
+                    const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
+                    const data = await client.graphql(WORKSTREAM_TASK_LIST_QUERY, {
+                        id: workstream.id,
+                        attachmentsFirst: 50,
+                    });
+                    if (!data.workstream) {
+                        throw new CLIError("Workstream not found", { json: common.json });
+                    }
+                    const todoLists = data.workstream.attachments.edges.flatMap((e) => e.node.todoList ? [e.node.todoList] : []);
+                    if (common.json) {
+                        printJson(runtime.stdout, withGuidanceJsonMetadata({
+                            workstreamId: workstream.id,
+                            workstreamName: workstream.name,
+                            todoLists,
+                        }, guidance));
+                    }
+                    else {
+                        if (todoLists.length === 0) {
+                            printLine(runtime.stdout, "No task lists attached to this workstream.");
+                        }
+                        else {
+                            const lines = [
+                                `${workstream.name} (${workstream.id}) - Tasks`,
+                                "",
+                            ];
+                            for (const list of todoLists) {
+                                const completed = list.totalItemCount - list.openItemCount;
+                                lines.push(`${list.title} (${completed}/${list.totalItemCount} complete)`);
+                                for (const item of list.items) {
+                                    const check = item.completed ? "[x]" : "[ ]";
+                                    const assignee = item.assignee
+                                        ? ` (@${item.assignee.handle})`
+                                        : "";
+                                    lines.push(`  ${check} ${item.title}${assignee}`);
+                                }
+                            }
+                            printLine(runtime.stdout, lines.join("\n"));
+                        }
+                    }
+                    return 0;
+                }
+                case "add": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: true,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                            workstream: { type: "string", short: "w" },
+                            title: { type: "string" },
+                            list: { type: "string" },
+                            description: { type: "string" },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const workstreamId = await resolveWorkstreamId(runtime, common, parsed.values.workstream);
+                    const taskTitle = parsed.values.title ??
+                        (parsed.positionals.length > 0
+                            ? parsed.positionals.join(" ")
+                            : await readTextFromStdin(runtime.stdin));
+                    if (!taskTitle) {
+                        throw new CLIError("Task title is required. Use --title or provide as positional argument.", { json: common.json });
+                    }
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
+                    const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
+                    let todoListId = parsed.values.list;
+                    if (!todoListId) {
+                        // Query existing TODOLIST attachments
+                        const data = await client.graphql(WORKSTREAM_TASK_LIST_QUERY, {
+                            id: workstream.id,
+                            attachmentsFirst: 50,
+                        });
+                        const lists = (data.workstream?.attachments.edges ?? []).flatMap((e) => (e.node.todoList ? [e.node.todoList] : []));
+                        if (lists.length === 1) {
+                            todoListId = lists[0].id;
+                        }
+                        else if (lists.length === 0) {
+                            // Auto-create a todo list with workstreamId for server-side attachment
+                            const createResult = await client.graphql(CREATE_TODO_LIST_MUTATION, {
+                                input: {
+                                    title: `${workstream.name} Tasks`,
+                                    workstreamId: workstream.id,
+                                },
+                            });
+                            todoListId = createResult.createTodoList.id;
+                        }
+                        else {
+                            const listSummary = lists
+                                .map((l) => `  ${l.id} (${l.title})`)
+                                .join("\n");
+                            throw new CLIError(`Multiple task lists found. Use --list <todoListId> to specify:\n${listSummary}`, { json: common.json });
+                        }
+                    }
+                    const result = await client.graphql(ADD_TODO_ITEM_MUTATION, {
+                        input: {
+                            todoListId,
+                            title: taskTitle,
+                            ...(parsed.values.description
+                                ? { description: parsed.values.description }
+                                : {}),
+                        },
+                    });
+                    if (common.json) {
+                        printJson(runtime.stdout, withGuidanceJsonMetadata({
+                            ok: true,
+                            workstreamId: workstream.id,
+                            todoListId,
+                            item: result.addTodoItem,
+                        }, guidance));
+                    }
+                    else {
+                        printLine(runtime.stdout, `Added task "${result.addTodoItem.title}" to ${workstream.id}.`);
+                    }
+                    return 0;
+                }
+                case "complete": {
+                    const parsed = parseArgs({
+                        args: args.slice(2),
+                        allowPositionals: true,
+                        options: {
+                            json: { type: "boolean" },
+                            help: { type: "boolean", short: "h" },
+                            profile: { type: "string" },
+                            "api-url": { type: "string" },
+                            undo: { type: "boolean" },
+                        },
+                    });
+                    const common = mergeCommonOptions(inherited, {
+                        json: parsed.values.json,
+                        profile: parsed.values.profile,
+                        apiUrl: parsed.values["api-url"],
+                    });
+                    if (parsed.values.help) {
+                        printWorkstreamHelp(runtime);
+                        return 0;
+                    }
+                    const taskItemId = parsed.positionals[0];
+                    if (!taskItemId) {
+                        throw new CLIError("Usage: corners workstream task complete <taskItemId> [--undo]", { json: common.json });
+                    }
+                    const completed = parsed.values.undo !== true;
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
+                    const result = await client.graphql(TOGGLE_TODO_ITEM_MUTATION, {
+                        id: taskItemId,
+                        completed,
+                    });
+                    if (common.json) {
+                        printJson(runtime.stdout, withGuidanceJsonMetadata({
+                            ok: true,
+                            item: result.toggleTodoItem,
+                        }, guidance));
+                    }
+                    else {
+                        const verb = completed ? "Completed" : "Reopened";
+                        printLine(runtime.stdout, `${verb} task "${result.toggleTodoItem.title}" (${result.toggleTodoItem.id}).`);
+                    }
+                    return 0;
+                }
+                default:
+                    throw new CLIError(`Unknown workstream task command: ${nested}`);
+            }
+        }
         default:
             throw new CLIError(`Unknown workstream command: ${subcommand}`);
     }
 }
+async function handleMcp(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printLine(runtime.stdout, "Usage: corners mcp serve [--profile <name>] [--api-url <url>]");
+        printLine(runtime.stdout, "");
+        printLine(runtime.stdout, "Run an MCP server over stdio exposing agent communication tools.");
+        printLine(runtime.stdout, "Configure in Claude Code: corners mcp serve");
+        return 0;
+    }
+    if (subcommand !== "serve") {
+        throw new CLIError(`Unknown mcp command: ${subcommand}. Use "corners mcp serve".`);
+    }
+    const parsed = parseArgs({
+        args: args.slice(1),
+        allowPositionals: false,
+        options: {
+            profile: { type: "string" },
+            "api-url": { type: "string" },
+        },
+    });
+    const common = mergeCommonOptions(inherited, {
+        profile: parsed.values.profile,
+        apiUrl: parsed.values["api-url"],
+    });
+    const { client } = await requireCommandProfile(runtime, common);
+    const { runMcpServer } = await import("./mcp-serve.js");
+    await runMcpServer(client);
+    return 0;
+}
 export async function runCli(argv, runtime = createRuntime()) {
     const normalizedArgv = argv[0] === "--" ? argv.slice(1) : argv;
     const parsed = parseLeadingCommonOptions(normalizedArgv);
@@ -2249,6 +2821,9 @@ export async function runCli(argv, runtime = createRuntime()) {
             else if (parsed.rest[1] === "guidance") {
                 printGuidanceHelp(runtime);
             }
+            else if (parsed.rest[1] === "skills") {
+                printSkillsHelp(runtime);
+            }
             else if (parsed.rest[1] === "init") {
                 printInitHelp(runtime);
             }
@@ -2272,6 +2847,8 @@ export async function runCli(argv, runtime = createRuntime()) {
             return handleInit(parsed.rest.slice(1), runtime, parsed.common);
         case "guidance":
             return handleGuidance(parsed.rest.slice(1), runtime, parsed.common);
+        case "skills":
+            return handleSkills(parsed.rest.slice(1), runtime, parsed.common);
         case "auth":
             return handleAuth(parsed.rest.slice(1), runtime, parsed.common);
         case "corner":
@@ -2281,6 +2858,8 @@ export async function runCli(argv, runtime = createRuntime()) {
         case "workstream":
         case "ws":
             return handleWorkstream(parsed.rest.slice(1), runtime, parsed.common);
+        case "mcp":
+            return handleMcp(parsed.rest.slice(1), runtime, parsed.common);
         default:
             throw new CLIError(`Unknown command: ${command}`, {
                 json: parsed.common.json,