@corners/cli 0.0.4 → 0.0.6

package/dist/cli.js

@@ -1,12 +1,38 @@
-import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { readFile, realpath } 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, 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) {
@@ -14,9 +40,11 @@ const WORKSTREAM_LOOKUP_QUERY = `
       accountId
       cornerId
       name
+      isOpen
       summary
       category
       status
+      statusDetails
       updatedAt
       topic {
         id
@@ -32,9 +60,11 @@ const WORKSTREAM_PULL_QUERY = `
       accountId
       cornerId
       name
+      isOpen
       summary
       category
       status
+      statusDetails
       createdAt
       updatedAt
       firstAttachmentActivityAt
@@ -124,6 +154,24 @@ const WORKSTREAM_PULL_QUERY = `
                 updatedAt
               }
             }
+            ... on WorkstreamTodoListAttachment {
+              todoList {
+                id
+                title
+                openItemCount
+                totalItemCount
+                items {
+                  id
+                  title
+                  completed
+                  itemIndex
+                  assignee {
+                    id
+                    handle
+                  }
+                }
+              }
+            }
           }
         }
       }
@@ -284,6 +332,91 @@ const RECORD_WORKSTREAM_UPDATE_MUTATION = `
     }
   }
 `;
+const UPDATE_WORKSTREAM_MUTATION = `
+  mutation CliUpdateWorkstream($id: ID!, $input: UpdateWorkstreamInput!) {
+    updateWorkstream(id: $id, input: $input) {
+      id
+      accountId
+      cornerId
+      name
+      isOpen
+      summary
+      category
+      status
+      statusDetails
+      updatedAt
+      topic {
+        id
+        name
+      }
+    }
+  }
+`;
+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)
@@ -319,9 +452,11 @@ const CREATE_WORKSTREAM_MUTATION = `
       id
       cornerId
       name
+      isOpen
       summary
       category
       status
+      statusDetails
       updatedAt
       topic {
         id
@@ -353,10 +488,11 @@ function printMainHelp(runtime) {
         "Commands:",
         "  auth login|logout|status",
         "  guidance status|sync",
+        "  skills list|status",
         "  init",
         "  corner use",
         "  whoami",
-        "  workstream (ws) list|use|current|create|pull|push|question|attach|reply-thread",
+        "  workstream (ws) list|use|current|create|pull|update|push|question|attach|reply-thread",
         "  help",
         "  version",
         "",
@@ -377,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",
@@ -417,17 +564,27 @@ 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 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",
         "",
         "Update types:",
         "  status | blocker | learning | outcome",
@@ -642,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`;
 }
@@ -710,8 +856,7 @@ async function resolveGuidanceState(root) {
         target,
         content: await readOptionalUtf8(join(root.rootDir, target.relativePath)),
     })));
-    const discoveredManagedTargets = GUIDANCE_TARGETS.map((target) => target.key)
-        .filter((key) => {
+    const discoveredManagedTargets = GUIDANCE_TARGETS.map((target) => target.key).filter((key) => {
         const entry = fileEntries.find((candidate) => candidate.target.key === key);
         return extractManagedGuidanceBlock(entry?.content ?? null) !== null;
     });
@@ -789,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,
@@ -875,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;
@@ -910,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,
@@ -948,14 +1093,17 @@ 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}  ${workstream.name}  ${workstream.status.toLowerCase()}${workstream.summary ? `  ${workstream.summary}` : ""}`;
+    return [
+        workstream.id,
+        workstream.name,
+        workstream.isOpen ? "open" : "archived",
+        workstream.status.toLowerCase(),
+        workstream.statusDetails ?? null,
+        workstream.summary ? workstream.summary : null,
+    ]
+        .filter((part) => Boolean(part))
+        .join("  ");
 }
 async function handleAuth(args, runtime, inherited) {
     const subcommand = args[0];
@@ -1266,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,
@@ -1275,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,
@@ -1287,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));
@@ -1307,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:",
@@ -1352,6 +1509,100 @@ async function handleInit(args, runtime, inherited) {
         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") {
@@ -1549,6 +1800,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, {
@@ -1560,44 +1812,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;
         }
@@ -1634,15 +1883,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;
         }
@@ -1665,12 +1922,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) {
@@ -1683,6 +1942,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"));
             }
@@ -1747,12 +2007,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, {
@@ -1764,12 +2025,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, {
@@ -1782,13 +2038,104 @@ 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"}`,
+                    `Lifecycle status: ${(snapshot.status ?? "SCOPING").toLowerCase()}`,
+                    `Status details: ${snapshot.statusDetails ?? "-"}`,
                     `Open questions: ${snapshot.openQuestions?.length ?? 0}`,
                     `Answered questions: ${snapshot.answeredQuestions?.length ?? 0}`,
                     `Attachments: ${snapshot.attachments?.totalCount ?? 0}`,
                     `Feed items returned: ${snapshot.feed?.totalCount ?? 0}`,
+                ];
+                // Append tasks from TodoList attachments
+                const todoLists = (snapshot.attachments?.edges ?? [])
+                    .filter((e) => e.node.__typename === "WorkstreamTodoListAttachment" &&
+                    e.node.todoList)
+                    .map((e) => 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: 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" },
+                },
+            });
+            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 rawStatusDetails = parsed.values["status-details"];
+            const clearStatusDetails = parsed.values["clear-status-details"] === true;
+            if (rawStatusDetails !== undefined && clearStatusDetails) {
+                throw new CLIError("Choose either --status-details or --clear-status-details, not both.", { json: common.json });
+            }
+            if (parsed.values.status === undefined &&
+                rawStatusDetails === undefined &&
+                !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, {
+                id: workstream.id,
+                input: {
+                    status: parsed.values.status === undefined
+                        ? undefined
+                        : toGraphQLWorkstreamStatus(parsed.values.status),
+                    statusDetails: clearStatusDetails
+                        ? null
+                        : rawStatusDetails === undefined
+                            ? undefined
+                            : rawStatusDetails,
+                },
+            });
+            const payload = {
+                ok: true,
+                workstream: result.updateWorkstream,
+            };
+            if (common.json) {
+                printJson(runtime.stdout, withGuidanceJsonMetadata(payload, guidance));
+            }
+            else {
+                printLine(runtime.stdout, [
+                    `Updated ${result.updateWorkstream.id}.`,
+                    `State: ${result.updateWorkstream.isOpen ? "open" : "archived"}`,
+                    `Lifecycle status: ${result.updateWorkstream.status.toLowerCase()}`,
+                    `Status details: ${result.updateWorkstream.statusDetails ?? "-"}`,
                 ].join("\n"));
             }
             return 0;
@@ -1802,6 +2149,7 @@ 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" },
@@ -1818,15 +2166,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 });
@@ -1879,12 +2222,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, {
@@ -1896,10 +2240,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, {
@@ -1930,6 +2271,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 },
@@ -1944,13 +2286,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 });
@@ -2027,12 +2366,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" },
                 },
@@ -2046,12 +2386,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, {
@@ -2111,6 +2451,212 @@ 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
+                        .filter((e) => e.node.todoList)
+                        .map((e) => 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 ?? [])
+                            .filter((e) => e.node.todoList)
+                            .map((e) => 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}`);
     }
@@ -2139,6 +2685,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);
             }
@@ -2162,6 +2711,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":