@corners/cli 0.0.1 → 0.0.4

package/dist/cli.js

@@ -1,31 +1,12 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
-import { basename } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { CornersApiClient as DefaultCornersApiClient, } from "./client.js";
-import { ConfigStore } from "./config.js";
-import { CLIError, getPackageVersion, openUrlInBrowser, printJson, printLine, readTextFromStdin, sleep, toGraphQLAttachmentKind, toGraphQLWorkstreamUpdateType, toIsoString, } from "./support.js";
-const LIST_WORKSTREAMS_QUERY = `
-  query CliListWorkstreams {
-    workstreams(filter: { status: ACTIVE }, first: 100) {
-      edges {
-        node {
-          id
-          cornerId
-          name
-          summary
-          category
-          status
-          updatedAt
-          topic {
-            id
-            name
-          }
-        }
-      }
-    }
-  }
-`;
+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";
 const WORKSTREAM_LOOKUP_QUERY = `
   query CliWorkstreamLookup($id: ID!) {
     workstream(id: $id) {
@@ -308,6 +289,47 @@ const REVOKE_MCP_SESSION_MUTATION = `
     revokeMCPSession(id: $id)
   }
 `;
+const WHOAMI_QUERY = `
+  query CliWhoAmI {
+    me {
+      id
+      handle
+      account {
+        id
+        workspace
+      }
+    }
+  }
+`;
+const LIST_MEMBER_CORNERS_QUERY = `
+  query CliMemberCorners {
+    memberCorners(first: 50) {
+      edges {
+        node {
+          id
+          name
+        }
+      }
+    }
+  }
+`;
+const CREATE_WORKSTREAM_MUTATION = `
+  mutation CliCreateWorkstream($input: CreateWorkstreamInput!) {
+    createWorkstream(input: $input) {
+      id
+      cornerId
+      name
+      summary
+      category
+      status
+      updatedAt
+      topic {
+        id
+        name
+      }
+    }
+  }
+`;
 function createRuntime() {
     return {
         config: new ConfigStore(),
@@ -315,6 +337,7 @@ function createRuntime() {
         stderr: process.stderr,
         stdin: process.stdin,
         cwd: process.cwd(),
+        prompts: undefined,
         openUrl: openUrlInBrowser,
         createClient: (input) => new DefaultCornersApiClient(input),
         getVersion: getPackageVersion,
@@ -329,7 +352,11 @@ function printMainHelp(runtime) {
         "",
         "Commands:",
         "  auth login|logout|status",
-        "  workstream (ws) list|use|current|pull|push|question|attach|reply-thread",
+        "  guidance status|sync",
+        "  init",
+        "  corner use",
+        "  whoami",
+        "  workstream (ws) list|use|current|create|pull|push|question|attach|reply-thread",
         "  help",
         "  version",
         "",
@@ -342,6 +369,23 @@ function printMainHelp(runtime) {
         "  --no-browser",
     ].join("\n"));
 }
+function printInitHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners init",
+        "",
+        "Usage:",
+        "  corners init [--profile <name>] [--api-url <url>] [--json]",
+    ].join("\n"));
+}
+function printGuidanceHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners guidance",
+        "",
+        "Usage:",
+        "  corners guidance status [--json]",
+        "  corners guidance sync [--json]",
+    ].join("\n"));
+}
 function printAuthHelp(runtime) {
     printLine(runtime.stdout, [
         "corners auth",
@@ -352,6 +396,22 @@ function printAuthHelp(runtime) {
         "  corners auth status [--profile <name>] [--json]",
     ].join("\n"));
 }
+function printCornerHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners corner",
+        "",
+        "Usage:",
+        "  corners corner use <cornerNameOrId> [--path <path>] [--json]",
+    ].join("\n"));
+}
+function printWhoamiHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners whoami",
+        "",
+        "Usage:",
+        "  corners whoami [--profile <name>] [--api-url <url>] [--json]",
+    ].join("\n"));
+}
 function printWorkstreamHelp(runtime) {
     printLine(runtime.stdout, [
         "corners workstream",
@@ -360,12 +420,13 @@ function printWorkstreamHelp(runtime) {
         "  corners workstream list [--json]",
         "  corners workstream use <workstreamId> [--json]",
         "  corners workstream current [--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 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 question answer <questionId> [--text <text>] [--json]",
-        "  corners workstream attach [workstreamId] --kind <kind> --entity-id <id> [--json]",
+        "  corners workstream attach <workstreamId> --kind <kind> --entity-id <id> [--json]",
         "  corners workstream reply-thread <threadId> [--text <text>] [--json]",
         "",
         "Update types:",
@@ -462,6 +523,83 @@ async function requireStoredProfile(runtime, common) {
         }),
     };
 }
+async function fetchCurrentIdentity(client) {
+    const data = await client.graphql(WHOAMI_QUERY);
+    return {
+        userId: data.me.id,
+        handle: data.me.handle ?? null,
+        accountId: data.me.account?.id ?? null,
+        workspace: data.me.account?.workspace ?? null,
+    };
+}
+async function maybeRefreshStoredProfileIdentity(input) {
+    try {
+        const identity = await fetchCurrentIdentity(input.client);
+        const nextProfile = {
+            ...input.profile,
+            userId: identity.userId,
+            handle: identity.handle,
+            accountId: identity.accountId,
+            workspace: identity.workspace,
+        };
+        if (nextProfile.userId !== input.profile.userId ||
+            nextProfile.handle !== (input.profile.handle ?? null) ||
+            nextProfile.accountId !== input.profile.accountId ||
+            nextProfile.workspace !== input.profile.workspace) {
+            await input.runtime.config.saveProfile(input.profileName, nextProfile, {
+                setActive: false,
+            });
+        }
+        return nextProfile;
+    }
+    catch {
+        return input.profile;
+    }
+}
+async function resolveAuthStatus(runtime, common) {
+    const selected = await runtime.config.getProfile(common.profile ?? null);
+    if (!selected) {
+        return {
+            loggedIn: false,
+            profile: common.profile ?? null,
+        };
+    }
+    const apiUrl = common.apiUrl ?? selected.profile.apiUrl;
+    const client = runtime.createClient({
+        apiUrl,
+        accessToken: selected.profile.accessToken,
+    });
+    let remote;
+    try {
+        remote = await client.validateSession();
+    }
+    catch (error) {
+        remote = {
+            valid: false,
+            error: error.message,
+        };
+    }
+    const profile = remote.valid
+        ? await maybeRefreshStoredProfileIdentity({
+            runtime,
+            profileName: selected.name,
+            profile: selected.profile,
+            client,
+        })
+        : selected.profile;
+    return {
+        loggedIn: true,
+        profile: selected.name,
+        apiUrl,
+        sessionId: profile.sessionId,
+        workspace: profile.workspace,
+        handle: profile.handle ?? null,
+        accountId: profile.accountId,
+        userId: profile.userId,
+        remoteValid: remote.valid,
+        remoteError: remote.valid ? null : (remote.error ?? null),
+    };
+}
 async function pollForDeviceToken(input) {
     const deadline = Date.now() + input.device.expires_in * 1000;
     let intervalMs = input.device.interval * 1000;
@@ -489,36 +627,336 @@ async function pollForDeviceToken(input) {
     printLine(input.stderr, "Device code expired before authorization completed.");
     throw new CLIError("Device code expired");
 }
-async function resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, explicitWorkstreamId) {
-    const workstreamId = explicitWorkstreamId ||
-        (await resolveBoundWorkstreamId(runtime, profileName));
+async function withPrompts(runtime, run) {
+    if (runtime.prompts) {
+        return run(runtime.prompts);
+    }
+    if (runtime.stdin.isTTY === false) {
+        throw new CLIError("`corners init` requires an interactive terminal.");
+    }
+    const prompts = createPromptApi(runtime.stdin, runtime.stderr);
+    try {
+        return await run(prompts);
+    }
+    finally {
+        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`;
+}
+function normalizeCornerLookupValue(value) {
+    const normalized = value.trim();
+    return normalized.startsWith("#") ? normalized.slice(1) : normalized;
+}
+function normalizeStoredRelativePath(rootDir, targetPath) {
+    const relativePath = relative(rootDir, targetPath);
+    if (!relativePath) {
+        return ".";
+    }
+    if (relativePath === ".." ||
+        relativePath.startsWith(`..${sep}`) ||
+        relativePath.includes(`${sep}..${sep}`)) {
+        throw new CLIError("The target path must stay within the initialized root.");
+    }
+    return relativePath.split(sep).join("/");
+}
+function resolvePathWithinRoot(rootDir, cwd, inputPath) {
+    const targetPath = inputPath ? resolve(cwd, inputPath) : resolve(cwd);
+    normalizeStoredRelativePath(rootDir, targetPath);
+    return targetPath;
+}
+function resolveCornerForRelativePath(config, relativePath) {
+    let selected = config.defaultCorner;
+    let selectedLength = 0;
+    for (const override of config.cornerOverrides) {
+        const matches = relativePath === override.path ||
+            relativePath.startsWith(`${override.path}/`);
+        if (!matches) {
+            continue;
+        }
+        if (override.path.length > selectedLength) {
+            selected = {
+                id: override.cornerId,
+                name: override.cornerName,
+            };
+            selectedLength = override.path.length;
+        }
+    }
+    return selected;
+}
+function resolveCornerForCwd(root, cwd) {
+    const absolutePath = resolvePathWithinRoot(root.rootDir, cwd);
+    const relativePath = normalizeStoredRelativePath(root.rootDir, absolutePath);
+    return {
+        relativePath,
+        corner: resolveCornerForRelativePath(root.config, relativePath),
+    };
+}
+async function resolveGuidanceState(root) {
+    const expectedBlock = buildExpectedManagedGuidanceBlock();
+    const fileEntries = await Promise.all(GUIDANCE_TARGETS.map(async (target) => ({
+        target,
+        content: await readOptionalUtf8(join(root.rootDir, target.relativePath)),
+    })));
+    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;
+    });
+    const configuredManagedTargets = root.config.guidance?.managedTargets;
+    const managedTargets = configuredManagedTargets !== undefined
+        ? normalizeGuidanceTargets(configuredManagedTargets)
+        : discoveredManagedTargets;
+    const files = fileEntries.map(({ target, content }) => {
+        if (content === null) {
+            return {
+                target: target.key,
+                path: target.relativePath,
+                state: "missing",
+            };
+        }
+        if (!managedTargets.includes(target.key)) {
+            return {
+                target: target.key,
+                path: target.relativePath,
+                state: "unmanaged",
+            };
+        }
+        return {
+            target: target.key,
+            path: target.relativePath,
+            state: extractManagedGuidanceBlock(content) === expectedBlock
+                ? "current"
+                : "stale",
+        };
+    });
+    const staleFiles = files
+        .filter((file) => file.state === "stale")
+        .map((file) => file.path);
+    return {
+        stale: staleFiles.length > 0,
+        lastSyncedAt: root.config.guidance?.syncedAt ?? null,
+        managedTargets,
+        staleFiles,
+        files,
+    };
+}
+function buildGuidanceWarning(guidance) {
+    if (!guidance.stale) {
+        return null;
+    }
+    const syncedSuffix = guidance.lastSyncedAt
+        ? ` Last synced: ${guidance.lastSyncedAt}.`
+        : "";
+    return `Warning: managed Corners guidance is out of date in ${guidance.staleFiles.length} file(s).${syncedSuffix} Run \`${GUIDANCE_SYNC_COMMAND}\`.`;
+}
+function buildGuidanceJsonMetadata(guidance) {
+    return {
+        stale: guidance.stale,
+        lastSyncedAt: guidance.lastSyncedAt,
+        staleFiles: guidance.staleFiles,
+        syncCommand: GUIDANCE_SYNC_COMMAND,
+    };
+}
+function withGuidanceJsonMetadata(payload, guidance) {
+    if (!guidance) {
+        return payload;
+    }
+    return {
+        ...payload,
+        _corners: {
+            guidance: buildGuidanceJsonMetadata(guidance),
+        },
+    };
+}
+async function resolveRootContext(runtime, common, root, options) {
+    const guidance = await resolveGuidanceState(root);
+    if ((options?.emitWarning ?? true) && !common.json) {
+        const warning = buildGuidanceWarning(guidance);
+        if (warning) {
+            printLine(runtime.stderr, warning);
+        }
+    }
+    return {
+        root,
+        guidance,
+    };
+}
+async function requireLocalRoot(runtime, common, options) {
+    const root = await runtime.config.findLocalRoot(runtime.cwd);
+    if (!root) {
+        throw new CLIError("No local Corners CLI root found. Run `corners init` from your project root first.", { json: common.json });
+    }
+    return resolveRootContext(runtime, common, root, options);
+}
+async function requirePinnedRootProfile(runtime, common, rootContext) {
+    const { root, guidance } = rootContext;
+    if (common.profile && common.profile !== root.config.profile) {
+        throw new CLIError(`This initialized root is pinned to profile ${root.config.profile}.`, { json: common.json });
+    }
+    const selected = await runtime.config.getProfile(root.config.profile);
+    if (!selected) {
+        throw new CLIError(`The pinned profile ${root.config.profile} is not available. Run \`corners auth login --profile ${root.config.profile}\` first.`, { json: common.json });
+    }
+    const pinnedApiUrl = normalizeApiUrl(root.config.apiUrl);
+    const requestedApiUrl = common.apiUrl ? normalizeApiUrl(common.apiUrl) : null;
+    if (requestedApiUrl && requestedApiUrl !== pinnedApiUrl) {
+        throw new CLIError(`This initialized root is pinned to API ${pinnedApiUrl}.`, { json: common.json });
+    }
+    if (root.config.workspace &&
+        selected.profile.workspace &&
+        root.config.workspace !== selected.profile.workspace) {
+        throw new CLIError(`The pinned profile ${root.config.profile} is now on workspace ${selected.profile.workspace}. Re-run \`corners init\` to refresh this root.`, { json: common.json });
+    }
+    const profile = {
+        ...selected.profile,
+        apiUrl: pinnedApiUrl,
+    };
+    return {
+        root,
+        guidance,
+        profileName: selected.name,
+        profile,
+        client: runtime.createClient({
+            apiUrl: profile.apiUrl,
+            accessToken: profile.accessToken,
+        }),
+    };
+}
+async function requireCommandProfile(runtime, common) {
+    const root = await runtime.config.findLocalRoot(runtime.cwd);
+    if (root) {
+        const rootContext = await resolveRootContext(runtime, common, root);
+        return requirePinnedRootProfile(runtime, common, rootContext);
+    }
+    const selected = await requireStoredProfile(runtime, common);
+    return {
+        root: null,
+        guidance: null,
+        ...selected,
+    };
+}
+async function listMemberCorners(client) {
+    const data = await client.graphql(LIST_MEMBER_CORNERS_QUERY);
+    return data.memberCorners.edges.map((edge) => edge.node);
+}
+function findMemberCorner(corners, value) {
+    const normalized = normalizeCornerLookupValue(value);
+    return (corners.find((corner) => corner.id === normalized) ??
+        corners.find((corner) => corner.name.toLowerCase() === normalized.toLowerCase()) ??
+        null);
+}
+async function resolveMemberCorner(client, common, value) {
+    const corners = await listMemberCorners(client);
+    const corner = findMemberCorner(corners, value);
+    if (!corner) {
+        throw new CLIError("Corner not found in your joined corners.", {
+            json: common.json,
+        });
+    }
+    return corner;
+}
+async function resolveExplicitWorkstream(client, common, workstreamId) {
     const data = await client.graphql(WORKSTREAM_LOOKUP_QUERY, { id: workstreamId });
     if (!data.workstream) {
         throw new CLIError("Workstream not found", { json: common.json });
     }
     return data.workstream;
 }
-async function resolveBoundWorkstreamId(runtime, profileName) {
-    const binding = await runtime.config.getBinding(runtime.cwd);
-    if (!binding) {
-        throw new CLIError("This directory is not bound to a workstream. Run `corners workstream use <workstreamId>` first.");
+function connectWorkstream(config, workstreamId) {
+    if (config.connectedWorkstreams.some((entry) => entry.id === workstreamId)) {
+        return config;
     }
-    if (binding.profile && binding.profile !== profileName) {
-        throw new CLIError(`This directory is bound to profile ${binding.profile}. Switch profiles or rebind the directory.`);
-    }
-    return binding.workstreamId;
+    return {
+        ...config,
+        connectedWorkstreams: [
+            ...config.connectedWorkstreams,
+            {
+                id: workstreamId,
+                connectedAt: toIsoString(),
+            },
+        ],
+    };
 }
-function maybeTakeWorkstreamId(positionals) {
-    if (positionals[0]?.startsWith("ws_")) {
+function upsertCornerOverride(config, relativePath, corner) {
+    if (relativePath === ".") {
         return {
-            workstreamId: positionals[0],
-            rest: positionals.slice(1),
+            ...config,
+            defaultCorner: corner,
         };
     }
+    const overrides = config.cornerOverrides.filter((entry) => entry.path !== relativePath);
+    overrides.push({
+        path: relativePath,
+        cornerId: corner.id,
+        cornerName: corner.name,
+        updatedAt: toIsoString(),
+    });
+    overrides.sort((left, right) => left.path.localeCompare(right.path));
     return {
-        rest: positionals,
+        ...config,
+        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,
+        guidance: {
+            managedTargets: normalizeGuidanceTargets(managedTargets),
+            syncedAt,
+            revision: buildGuidanceRevision(),
+        },
+    };
+}
+function ensureGitignoreEntry(existing) {
+    const content = existing ?? "";
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.includes(".corners") ||
+        lines.includes(".corners/") ||
+        lines.includes(LOCAL_ROOT_CONFIG_RELATIVE_PATH)) {
+        return ensureTrailingNewline(content);
+    }
+    const trimmed = content.trimEnd();
+    if (!trimmed) {
+        return `${LOCAL_ROOT_CONFIG_RELATIVE_PATH}\n`;
+    }
+    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}` : ""}`;
+}
 async function handleAuth(args, runtime, inherited) {
     const subcommand = args[0];
     if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -579,15 +1017,32 @@ async function handleAuth(args, runtime, inherited) {
             if (!token.access_token) {
                 throw new CLIError("Login completed without an access token");
             }
-            const profile = {
+            let profile = {
                 apiUrl: client.apiUrl,
                 accessToken: token.access_token,
                 sessionId: token.session_id ?? null,
                 workspace: token.workspace ?? null,
                 accountId: token.account_id ?? null,
                 userId: token.user_id ?? null,
+                handle: null,
                 createdAt: toIsoString(),
             };
+            try {
+                const identity = await fetchCurrentIdentity(runtime.createClient({
+                    apiUrl: profile.apiUrl,
+                    accessToken: profile.accessToken,
+                }));
+                profile = {
+                    ...profile,
+                    workspace: identity.workspace,
+                    accountId: identity.accountId,
+                    userId: identity.userId,
+                    handle: identity.handle,
+                };
+            }
+            catch {
+                // Best-effort profile enrichment. Authentication already succeeded.
+            }
             await runtime.config.saveProfile(profileName, profile, {
                 setActive: true,
             });
@@ -598,6 +1053,7 @@ async function handleAuth(args, runtime, inherited) {
                     apiUrl: profile.apiUrl,
                     sessionId: profile.sessionId,
                     workspace: profile.workspace,
+                    handle: profile.handle,
                     accountId: profile.accountId,
                     userId: profile.userId,
                 });
@@ -693,12 +1149,8 @@ async function handleAuth(args, runtime, inherited) {
                 printAuthHelp(runtime);
                 return 0;
             }
-            const selected = await runtime.config.getProfile(common.profile ?? null);
-            if (!selected) {
-                const status = {
-                    loggedIn: false,
-                    profile: common.profile ?? null,
-                };
+            const status = await resolveAuthStatus(runtime, common);
+            if (!status.loggedIn) {
                 if (common.json) {
                     printJson(runtime.stdout, status);
                 }
@@ -707,31 +1159,6 @@ async function handleAuth(args, runtime, inherited) {
                 }
                 return 0;
             }
-            const client = runtime.createClient({
-                apiUrl: common.apiUrl ?? selected.profile.apiUrl,
-                accessToken: selected.profile.accessToken,
-            });
-            let remote;
-            try {
-                remote = await client.validateSession();
-            }
-            catch (error) {
-                remote = {
-                    valid: false,
-                    error: error.message,
-                };
-            }
-            const status = {
-                loggedIn: true,
-                profile: selected.name,
-                apiUrl: common.apiUrl ?? selected.profile.apiUrl,
-                sessionId: selected.profile.sessionId,
-                workspace: selected.profile.workspace,
-                accountId: selected.profile.accountId,
-                userId: selected.profile.userId,
-                remoteValid: remote.valid,
-                remoteError: remote.valid ? null : (remote.error ?? null),
-            };
             if (common.json) {
                 printJson(runtime.stdout, status);
             }
@@ -740,6 +1167,7 @@ async function handleAuth(args, runtime, inherited) {
                     `Profile: ${status.profile}`,
                     `API URL: ${status.apiUrl}`,
                     `Workspace: ${status.workspace ?? "-"}`,
+                    `Handle: ${status.handle ? `@${status.handle}` : "-"}`,
                     `Account: ${status.accountId ?? "-"}`,
                     `User: ${status.userId ?? "-"}`,
                     `Session: ${status.sessionId ?? "-"}`,
@@ -752,6 +1180,359 @@ async function handleAuth(args, runtime, inherited) {
             throw new CLIError(`Unknown auth command: ${subcommand}`);
     }
 }
+async function handleWhoAmI(args, runtime, inherited) {
+    const parsed = parseArgs({
+        args,
+        allowPositionals: false,
+        options: {
+            json: { type: "boolean" },
+            help: { type: "boolean", short: "h" },
+            profile: { type: "string" },
+            "api-url": { type: "string" },
+        },
+    });
+    const common = mergeCommonOptions(inherited, {
+        json: parsed.values.json,
+        profile: parsed.values.profile,
+        apiUrl: parsed.values["api-url"],
+    });
+    if (parsed.values.help) {
+        printWhoamiHelp(runtime);
+        return 0;
+    }
+    const status = await resolveAuthStatus(runtime, common);
+    if (!status.loggedIn) {
+        if (common.json) {
+            printJson(runtime.stdout, status);
+        }
+        else {
+            printLine(runtime.stdout, "Not logged in.");
+        }
+        return 0;
+    }
+    if (common.json) {
+        printJson(runtime.stdout, status);
+    }
+    else {
+        const identity = status.handle
+            ? `@${status.handle}`
+            : (status.userId ?? status.profile);
+        const workspaceSuffix = status.workspace ? ` (${status.workspace})` : "";
+        printLine(runtime.stdout, `${identity}${workspaceSuffix}`);
+    }
+    return 0;
+}
+async function handleInit(args, runtime, inherited) {
+    const parsed = parseArgs({
+        args,
+        allowPositionals: false,
+        options: {
+            json: { type: "boolean" },
+            help: { type: "boolean", short: "h" },
+            profile: { type: "string" },
+            "api-url": { type: "string" },
+        },
+    });
+    const common = mergeCommonOptions(inherited, {
+        json: parsed.values.json,
+        profile: parsed.values.profile,
+        apiUrl: parsed.values["api-url"],
+    });
+    if (parsed.values.help) {
+        printInitHelp(runtime);
+        return 0;
+    }
+    const currentRootPath = await realpath(runtime.cwd);
+    const existingRoot = await runtime.config.findLocalRoot(runtime.cwd);
+    if (existingRoot && existingRoot.rootDir !== currentRootPath) {
+        throw new CLIError(`This directory is already inside initialized root ${existingRoot.rootDir}. Run \`corners init\` there.`, { json: common.json });
+    }
+    const { profileName, profile, client } = await requireStoredProfile(runtime, common);
+    const joinedCorners = await listMemberCorners(client);
+    if (joinedCorners.length === 0) {
+        throw new CLIError("No joined corners are available for this profile.", {
+            json: common.json,
+        });
+    }
+    const rootDir = existingRoot?.rootDir ?? currentRootPath;
+    const existingConfig = existingRoot?.config ?? null;
+    return withPrompts(runtime, async (prompts) => {
+        const selectedTargets = [];
+        for (const target of GUIDANCE_TARGETS) {
+            const include = await prompts.confirm(target.label, {
+                defaultValue: true,
+            });
+            if (include) {
+                selectedTargets.push(target);
+            }
+        }
+        const selectedCornerId = await prompts.select("Choose the default corner for this local root.", joinedCorners.map((corner) => ({
+            label: `${corner.name} (${corner.id})`,
+            value: corner.id,
+        })), {
+            defaultValue: existingConfig?.defaultCorner.id ?? joinedCorners[0]?.id,
+        });
+        const defaultCorner = joinedCorners.find((corner) => corner.id === selectedCornerId) ??
+            joinedCorners[0];
+        const syncedAt = toIsoString();
+        const nextLocalConfig = withUpdatedGuidanceConfig({
+            version: 1,
+            profile: profileName,
+            workspace: profile.workspace,
+            apiUrl: profile.apiUrl,
+            defaultCorner: {
+                id: defaultCorner.id,
+                name: defaultCorner.name,
+            },
+            cornerOverrides: existingConfig?.cornerOverrides ?? [],
+            connectedWorkstreams: existingConfig?.connectedWorkstreams ?? [],
+        }, selectedTargets.map((target) => target.key), syncedAt);
+        const plannedEdits = [];
+        const gitignorePath = join(rootDir, ".gitignore");
+        const gitignoreContent = ensureGitignoreEntry(await readOptionalUtf8(gitignorePath));
+        const gitignoreEdit = await buildPlannedEdit(gitignorePath, gitignoreContent);
+        if (gitignoreEdit) {
+            plannedEdits.push(gitignoreEdit);
+        }
+        const localConfigPath = runtime.config.getLocalConfigPath(rootDir);
+        const localConfigEdit = await buildPlannedEdit(localConfigPath, `${JSON.stringify(nextLocalConfig, null, 2)}\n`);
+        if (localConfigEdit) {
+            plannedEdits.push(localConfigEdit);
+        }
+        for (const target of selectedTargets) {
+            const targetPath = join(rootDir, target.relativePath);
+            const nextContent = buildGuidanceFileContent(target.key, await readOptionalUtf8(targetPath));
+            const edit = await buildPlannedEdit(targetPath, nextContent);
+            if (edit) {
+                plannedEdits.push(edit);
+            }
+        }
+        if (plannedEdits.length > 0 && !common.json) {
+            printLine(runtime.stderr, [
+                "Planned changes:",
+                ...plannedEdits.map((edit) => `  ${edit.action} ${relative(rootDir, edit.path) || "."}`),
+            ].join("\n"));
+        }
+        if (plannedEdits.length > 0) {
+            const confirmed = await prompts.confirm("Proceed with these changes?", {
+                defaultValue: true,
+            });
+            if (!confirmed) {
+                if (common.json) {
+                    printJson(runtime.stdout, {
+                        ok: false,
+                        root: rootDir,
+                        aborted: true,
+                    });
+                }
+                else {
+                    printLine(runtime.stdout, "Aborted. No files were changed.");
+                }
+                return 0;
+            }
+            await writePlannedEdits(plannedEdits);
+        }
+        const payload = {
+            ok: true,
+            root: rootDir,
+            profile: profileName,
+            workspace: profile.workspace,
+            defaultCorner,
+            files: plannedEdits.map((edit) => ({
+                action: edit.action,
+                path: relative(rootDir, edit.path) || ".",
+            })),
+        };
+        if (common.json) {
+            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.`);
+        }
+        return 0;
+    });
+}
+async function handleGuidance(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printGuidanceHelp(runtime);
+        return 0;
+    }
+    switch (subcommand) {
+        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) {
+                printGuidanceHelp(runtime);
+                return 0;
+            }
+            const rootContext = await requireLocalRoot(runtime, common, {
+                emitWarning: false,
+            });
+            const payload = {
+                ok: true,
+                root: rootContext.root.rootDir,
+                guidance: rootContext.guidance,
+            };
+            if (common.json) {
+                printJson(runtime.stdout, payload);
+            }
+            else {
+                printLine(runtime.stdout, [
+                    `Root: ${payload.root}`,
+                    `Stale: ${payload.guidance.stale ? "yes" : "no"}`,
+                    `Last synced: ${payload.guidance.lastSyncedAt ?? "-"}`,
+                    `Managed targets: ${payload.guidance.managedTargets.join(", ") || "-"}`,
+                    ...payload.guidance.files.map((file) => `${file.path}: ${file.state}`),
+                ].join("\n"));
+            }
+            return 0;
+        }
+        case "sync": {
+            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) {
+                printGuidanceHelp(runtime);
+                return 0;
+            }
+            const rootContext = await requireLocalRoot(runtime, common, {
+                emitWarning: false,
+            });
+            const managedTargets = rootContext.root.config.guidance?.managedTargets !== undefined
+                ? normalizeGuidanceTargets(rootContext.root.config.guidance.managedTargets)
+                : rootContext.guidance.managedTargets;
+            const edits = [];
+            const actions = new Map();
+            for (const target of GUIDANCE_TARGETS) {
+                if (!managedTargets.includes(target.key)) {
+                    actions.set(target.key, "skipped");
+                    continue;
+                }
+                const targetPath = join(rootContext.root.rootDir, target.relativePath);
+                const nextContent = buildGuidanceFileContent(target.key, await readOptionalUtf8(targetPath));
+                const edit = await buildPlannedEdit(targetPath, nextContent);
+                if (edit) {
+                    edits.push(edit);
+                    actions.set(target.key, edit.action);
+                }
+                else {
+                    actions.set(target.key, "unchanged");
+                }
+            }
+            if (edits.length > 0) {
+                await writePlannedEdits(edits);
+            }
+            const syncedAt = toIsoString();
+            const nextConfig = withUpdatedGuidanceConfig(rootContext.root.config, managedTargets, syncedAt);
+            await runtime.config.writeLocalConfig(rootContext.root.rootDir, nextConfig);
+            const nextRoot = {
+                ...rootContext.root,
+                config: nextConfig,
+            };
+            const nextGuidance = await resolveGuidanceState(nextRoot);
+            const guidance = {
+                ...nextGuidance,
+                files: nextGuidance.files.map((file) => ({
+                    ...file,
+                    action: actions.get(file.target) ?? "skipped",
+                })),
+            };
+            const payload = {
+                ok: true,
+                root: nextRoot.rootDir,
+                guidance,
+            };
+            if (common.json) {
+                printJson(runtime.stdout, payload);
+            }
+            else {
+                const updatedCount = guidance.files.filter((file) => file.action === "create" || file.action === "update").length;
+                printLine(runtime.stdout, `Synchronized Corners guidance at ${payload.root}. Updated ${updatedCount} file(s).`);
+            }
+            return 0;
+        }
+        default:
+            throw new CLIError(`Unknown guidance command: ${subcommand}`);
+    }
+}
+async function handleCorner(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printCornerHelp(runtime);
+        return 0;
+    }
+    switch (subcommand) {
+        case "use": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    path: { type: "string" },
+                },
+            });
+            const common = mergeCommonOptions(inherited, {
+                json: parsed.values.json,
+                profile: parsed.values.profile,
+                apiUrl: parsed.values["api-url"],
+            });
+            if (parsed.values.help) {
+                printCornerHelp(runtime);
+                return 0;
+            }
+            const cornerNameOrId = parsed.positionals[0];
+            if (!cornerNameOrId) {
+                throw new CLIError("Usage: corners corner use <cornerNameOrId> [--path <path>]", { json: common.json });
+            }
+            const rootContext = await requireLocalRoot(runtime, common);
+            const { root, guidance, client } = await requirePinnedRootProfile(runtime, common, rootContext);
+            const corner = await resolveMemberCorner(client, common, cornerNameOrId);
+            const cwdPath = await realpath(runtime.cwd);
+            const targetAbsolutePath = resolvePathWithinRoot(root.rootDir, cwdPath, parsed.values.path);
+            const relativePath = normalizeStoredRelativePath(root.rootDir, targetAbsolutePath);
+            const nextConfig = upsertCornerOverride(root.config, relativePath, {
+                id: corner.id,
+                name: corner.name,
+            });
+            await runtime.config.writeLocalConfig(root.rootDir, nextConfig);
+            if (common.json) {
+                printJson(runtime.stdout, withGuidanceJsonMetadata({
+                    ok: true,
+                    root: root.rootDir,
+                    path: relativePath,
+                    corner,
+                }, guidance));
+            }
+            else {
+                printLine(runtime.stdout, `Set default corner for ${relativePath} to ${corner.name}.`);
+            }
+            return 0;
+        }
+        default:
+            throw new CLIError(`Unknown corner command: ${subcommand}`);
+    }
+}
 async function handleWorkstream(args, runtime, inherited) {
     const subcommand = args[0];
     if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -779,16 +1560,44 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const { client } = await requireStoredProfile(runtime, common);
-            const data = await client.graphql(LIST_WORKSTREAMS_QUERY);
-            const workstreams = data.workstreams.edges.map((edge) => edge.node);
+            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);
             if (common.json) {
-                printJson(runtime.stdout, workstreams);
+                printJson(runtime.stdout, withGuidanceJsonMetadata({
+                    root: root.rootDir,
+                    workstreams,
+                    missingWorkstreamIds,
+                }, guidance));
             }
             else {
-                printLine(runtime.stdout, workstreams
-                    .map((workstream) => `${workstream.id}  ${workstream.name}  ${workstream.status.toLowerCase()}${workstream.summary ? `  ${workstream.summary}` : ""}`)
-                    .join("\n"));
+                if (missingWorkstreamIds.length > 0) {
+                    printLine(runtime.stderr, missingWorkstreamIds
+                        .map((workstreamId) => `Warning: connected workstream ${workstreamId} is missing or inaccessible.`)
+                        .join("\n"));
+                }
+                printLine(runtime.stdout, workstreams.length > 0
+                    ? workstreams.map(formatWorkstreamLine).join("\n")
+                    : "No workstreams are connected to this local environment.");
             }
             return 0;
         }
@@ -818,26 +1627,22 @@ async function handleWorkstream(args, runtime, inherited) {
                     json: common.json,
                 });
             }
-            const { profileName, profile, client } = await requireStoredProfile(runtime, common);
-            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
-            await runtime.config.setBinding(runtime.cwd, {
-                profile: profileName,
-                workspace: profile.workspace ?? "",
-                workstreamId: workstream.id,
-                cornerId: workstream.cornerId,
-                boundAt: toIsoString(),
-            });
+            const rootContext = await requireLocalRoot(runtime, common);
+            const { root, guidance, client } = await requirePinnedRootProfile(runtime, common, rootContext);
+            const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
+            const nextConfig = connectWorkstream(root.config, workstream.id);
+            if (nextConfig !== root.config) {
+                await runtime.config.writeLocalConfig(root.rootDir, nextConfig);
+            }
             if (common.json) {
-                printJson(runtime.stdout, {
+                printJson(runtime.stdout, withGuidanceJsonMetadata({
                     ok: true,
-                    cwd: runtime.cwd,
-                    profile: profileName,
-                    workspace: profile.workspace,
+                    root: root.rootDir,
                     workstream,
-                });
+                }, guidance));
             }
             else {
-                printLine(runtime.stdout, `Bound ${runtime.cwd} to ${workstream.id} (${workstream.name}).`);
+                printLine(runtime.stdout, `Connected ${workstream.id} (${workstream.name}) to ${root.rootDir}.`);
             }
             return 0;
         }
@@ -857,33 +1662,88 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const binding = await runtime.config.getBinding(runtime.cwd);
-            if (!binding) {
-                if (common.json) {
-                    printJson(runtime.stdout, { cwd: runtime.cwd, binding: null });
-                }
-                else {
-                    printLine(runtime.stdout, "No workstream is bound to this directory.");
-                }
-                return 0;
-            }
+            const { root, guidance } = await requireLocalRoot(runtime, common);
+            const cwdPath = await realpath(runtime.cwd);
+            const resolvedCorner = resolveCornerForCwd(root, cwdPath);
+            const payload = {
+                cwd: runtime.cwd,
+                root: root.rootDir,
+                profile: root.config.profile,
+                workspace: root.config.workspace,
+                resolvedCorner,
+                connectedWorkstreamIds: root.config.connectedWorkstreams.map((entry) => entry.id),
+            };
             if (common.json) {
-                printJson(runtime.stdout, {
-                    cwd: runtime.cwd,
-                    binding,
-                });
+                printJson(runtime.stdout, withGuidanceJsonMetadata(payload, guidance));
             }
             else {
                 printLine(runtime.stdout, [
-                    `Directory: ${runtime.cwd}`,
-                    `Profile: ${binding.profile ?? "-"}`,
-                    `Workspace: ${binding.workspace || "-"}`,
-                    `Workstream: ${binding.workstreamId}`,
-                    `Corner: ${binding.cornerId}`,
+                    `Root: ${payload.root}`,
+                    `Directory: ${payload.cwd}`,
+                    `Profile: ${payload.profile}`,
+                    `Workspace: ${payload.workspace ?? "-"}`,
+                    `Resolved corner: ${payload.resolvedCorner.corner.name} (${payload.resolvedCorner.corner.id})`,
+                    `Connected workstreams: ${payload.connectedWorkstreamIds.length}`,
                 ].join("\n"));
             }
             return 0;
         }
+        case "create": {
+            const parsed = parseArgs({
+                args: args.slice(1),
+                allowPositionals: true,
+                options: {
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    profile: { type: "string" },
+                    "api-url": { type: "string" },
+                    summary: { type: "string" },
+                    corner: { 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 name = parsed.positionals.join(" ").trim();
+            if (!name) {
+                throw new CLIError("Usage: corners workstream create <name> [--summary <text>] [--corner <cornerNameOrId>]", { json: common.json });
+            }
+            const rootContext = await requireLocalRoot(runtime, common);
+            const { root, guidance, client } = await requirePinnedRootProfile(runtime, common, rootContext);
+            const cwdPath = await realpath(runtime.cwd);
+            const corner = parsed.values.corner
+                ? await resolveMemberCorner(client, common, parsed.values.corner)
+                : resolveCornerForCwd(root, cwdPath).corner;
+            const result = await client.graphql(CREATE_WORKSTREAM_MUTATION, {
+                input: {
+                    cornerId: corner.id,
+                    name,
+                    summary: parsed.values.summary,
+                },
+            });
+            const nextConfig = connectWorkstream(root.config, result.createWorkstream.id);
+            if (nextConfig !== root.config) {
+                await runtime.config.writeLocalConfig(root.rootDir, nextConfig);
+            }
+            if (common.json) {
+                printJson(runtime.stdout, withGuidanceJsonMetadata({
+                    ok: true,
+                    root: root.rootDir,
+                    corner,
+                    workstream: result.createWorkstream,
+                }, guidance));
+            }
+            else {
+                printLine(runtime.stdout, `Created ${result.createWorkstream.id} (${result.createWorkstream.name}) in ${corner.name}.`);
+            }
+            return 0;
+        }
         case "pull": {
             const parsed = parseArgs({
                 args: args.slice(1),
@@ -904,16 +1764,21 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
-            const { profileName, client } = await requireStoredProfile(runtime, common);
-            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            const workstreamId = parsed.positionals[0];
+            if (!workstreamId) {
+                throw new CLIError("Usage: corners workstream pull <workstreamId>", {
+                    json: common.json,
+                });
+            }
+            const { guidance, client } = await requireCommandProfile(runtime, common);
+            const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             const data = await client.graphql(WORKSTREAM_PULL_QUERY, {
                 id: workstream.id,
                 attachmentsFirst: 50,
                 feedFirst: 20,
             });
             if (common.json) {
-                printJson(runtime.stdout, data.workstream);
+                printJson(runtime.stdout, withGuidanceJsonMetadata(data.workstream, guidance));
             }
             else {
                 const snapshot = data.workstream;
@@ -953,16 +1818,21 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const { workstreamId, rest } = maybeTakeWorkstreamId(parsed.positionals);
+            const workstreamId = parsed.positionals[0];
+            if (!workstreamId) {
+                throw new CLIError("Usage: corners workstream push <workstreamId>", {
+                    json: common.json,
+                });
+            }
             const message = parsed.values.message ??
-                (rest.length > 0
-                    ? rest.join(" ")
+                (parsed.positionals.length > 1
+                    ? parsed.positionals.slice(1).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 });
             }
-            const { profileName, client } = await requireStoredProfile(runtime, common);
-            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            const { guidance, client } = await requireCommandProfile(runtime, common);
+            const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             let createdDocument = null;
             if (parsed.values.file) {
                 const documentContent = await readFile(parsed.values.file, "utf8");
@@ -992,7 +1862,7 @@ async function handleWorkstream(args, runtime, inherited) {
                 document: createdDocument,
             };
             if (common.json) {
-                printJson(runtime.stdout, payload);
+                printJson(runtime.stdout, withGuidanceJsonMetadata(payload, guidance));
             }
             else {
                 printLine(runtime.stdout, `Recorded ${String(parsed.values.type ?? "status")} update on ${workstream.id}.`);
@@ -1026,9 +1896,12 @@ async function handleWorkstream(args, runtime, inherited) {
                         printWorkstreamHelp(runtime);
                         return 0;
                     }
-                    const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
-                    const { profileName, client } = await requireStoredProfile(runtime, common);
-                    const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+                    const workstreamId = parsed.positionals[0];
+                    if (!workstreamId) {
+                        throw new CLIError("Usage: corners workstream question list <workstreamId>", { json: common.json });
+                    }
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
+                    const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
                     const data = await client.graphql(WORKSTREAM_QUESTION_LIST_QUERY, {
                         id: workstream.id,
                     });
@@ -1036,7 +1909,7 @@ async function handleWorkstream(args, runtime, inherited) {
                         throw new CLIError("Workstream not found", { json: common.json });
                     }
                     if (common.json) {
-                        printJson(runtime.stdout, data.workstream);
+                        printJson(runtime.stdout, withGuidanceJsonMetadata(data.workstream, guidance));
                     }
                     else {
                         printLine(runtime.stdout, [
@@ -1071,16 +1944,19 @@ async function handleWorkstream(args, runtime, inherited) {
                         printWorkstreamHelp(runtime);
                         return 0;
                     }
-                    const { workstreamId, rest } = maybeTakeWorkstreamId(parsed.positionals);
+                    const workstreamId = parsed.positionals[0];
+                    if (!workstreamId) {
+                        throw new CLIError("Usage: corners workstream question ask <workstreamId> [--question <text>]", { json: common.json });
+                    }
                     const question = parsed.values.question ??
-                        (rest.length > 0
-                            ? rest.join(" ")
+                        (parsed.positionals.length > 1
+                            ? parsed.positionals.slice(1).join(" ")
                             : await readTextFromStdin(runtime.stdin));
                     if (!question) {
                         throw new CLIError("Question text is required. Use --question or pipe text on stdin.", { json: common.json });
                     }
-                    const { profileName, client } = await requireStoredProfile(runtime, common);
-                    const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
+                    const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
                     const result = await client.graphql(CREATE_WORKSTREAM_QUESTION_MUTATION, {
                         input: {
                             workstreamId: workstream.id,
@@ -1090,7 +1966,7 @@ async function handleWorkstream(args, runtime, inherited) {
                         },
                     });
                     if (common.json) {
-                        printJson(runtime.stdout, result.createWorkstreamQuestion);
+                        printJson(runtime.stdout, withGuidanceJsonMetadata(result.createWorkstreamQuestion, guidance));
                     }
                     else {
                         printLine(runtime.stdout, `Created question on ${workstream.id}.`);
@@ -1131,13 +2007,13 @@ async function handleWorkstream(args, runtime, inherited) {
                             json: common.json,
                         });
                     }
-                    const { client } = await requireStoredProfile(runtime, common);
+                    const { guidance, client } = await requireCommandProfile(runtime, common);
                     const result = await client.graphql(ANSWER_WORKSTREAM_QUESTION_MUTATION, {
                         questionId,
                         answerText: answer,
                     });
                     if (common.json) {
-                        printJson(runtime.stdout, result.answerWorkstreamQuestion);
+                        printJson(runtime.stdout, withGuidanceJsonMetadata(result.answerWorkstreamQuestion, guidance));
                     }
                     else {
                         printLine(runtime.stdout, `Answered ${questionId}.`);
@@ -1170,21 +2046,21 @@ async function handleWorkstream(args, runtime, inherited) {
                 printWorkstreamHelp(runtime);
                 return 0;
             }
-            const { workstreamId } = maybeTakeWorkstreamId(parsed.positionals);
+            const workstreamId = parsed.positionals[0];
             const kind = parsed.values.kind;
             const entityId = parsed.values["entity-id"];
-            if (!kind || !entityId) {
-                throw new CLIError("Usage: corners workstream attach [workstreamId] --kind <kind> --entity-id <id>", { json: common.json });
+            if (!workstreamId || !kind || !entityId) {
+                throw new CLIError("Usage: corners workstream attach <workstreamId> --kind <kind> --entity-id <id>", { json: common.json });
             }
-            const { profileName, client } = await requireStoredProfile(runtime, common);
-            const workstream = await resolveExplicitOrBoundWorkstream(runtime, common, client, profileName, workstreamId);
+            const { guidance, client } = await requireCommandProfile(runtime, common);
+            const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
             const result = await client.graphql(ADD_WORKSTREAM_ATTACHMENT_MUTATION, {
                 workstreamId: workstream.id,
                 kind: toGraphQLAttachmentKind(kind),
                 entityId,
             });
             if (common.json) {
-                printJson(runtime.stdout, result.addWorkstreamAttachment);
+                printJson(runtime.stdout, withGuidanceJsonMetadata(result.addWorkstreamAttachment, guidance));
             }
             else {
                 printLine(runtime.stdout, `Attached ${kind}:${entityId} to ${workstream.id}.`);
@@ -1220,7 +2096,7 @@ async function handleWorkstream(args, runtime, inherited) {
             if (!threadId || !text) {
                 throw new CLIError("Usage: corners workstream reply-thread <threadId> [--text <text>]", { json: common.json });
             }
-            const { client } = await requireStoredProfile(runtime, common);
+            const { guidance, client } = await requireCommandProfile(runtime, common);
             const result = await client.graphql(REPLY_ARTIFACT_THREAD_MUTATION, {
                 id: threadId,
                 input: {
@@ -1228,7 +2104,7 @@ async function handleWorkstream(args, runtime, inherited) {
                 },
             });
             if (common.json) {
-                printJson(runtime.stdout, result.replyArtifactThread);
+                printJson(runtime.stdout, withGuidanceJsonMetadata(result.replyArtifactThread, guidance));
             }
             else {
                 printLine(runtime.stdout, `Replied to ${threadId}.`);
@@ -1260,6 +2136,18 @@ export async function runCli(argv, runtime = createRuntime()) {
             if (parsed.rest[1] === "auth") {
                 printAuthHelp(runtime);
             }
+            else if (parsed.rest[1] === "guidance") {
+                printGuidanceHelp(runtime);
+            }
+            else if (parsed.rest[1] === "init") {
+                printInitHelp(runtime);
+            }
+            else if (parsed.rest[1] === "corner") {
+                printCornerHelp(runtime);
+            }
+            else if (parsed.rest[1] === "whoami") {
+                printWhoamiHelp(runtime);
+            }
             else if (parsed.rest[1] === "workstream" || parsed.rest[1] === "ws") {
                 printWorkstreamHelp(runtime);
             }
@@ -1270,8 +2158,16 @@ export async function runCli(argv, runtime = createRuntime()) {
         case "version":
             printLine(runtime.stdout, runtime.getVersion());
             return 0;
+        case "init":
+            return handleInit(parsed.rest.slice(1), runtime, parsed.common);
+        case "guidance":
+            return handleGuidance(parsed.rest.slice(1), runtime, parsed.common);
         case "auth":
             return handleAuth(parsed.rest.slice(1), runtime, parsed.common);
+        case "corner":
+            return handleCorner(parsed.rest.slice(1), runtime, parsed.common);
+        case "whoami":
+            return handleWhoAmI(parsed.rest.slice(1), runtime, parsed.common);
         case "workstream":
         case "ws":
             return handleWorkstream(parsed.rest.slice(1), runtime, parsed.common);