@corners/cli 0.0.8 → 0.0.10

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,WAAW,EASZ,MAAM,aAAa,CAAC;AAWrB,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AA0f/D,UAAU,OAAO;IACf,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE;QAC7B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC7B,KAAK,gBAAgB,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC;CACnC;AA60GD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,OAAyB,GACjC,OAAO,CAAC,MAAM,CAAC,CAiEjB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,WAAW,EASZ,MAAM,aAAa,CAAC;AAUrB,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AA0f/D,UAAU,OAAO;IACf,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE;QAC7B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC7B,KAAK,gBAAgB,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC;CACnC;AAkvHD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,OAAyB,GACjC,OAAO,CAAC,MAAM,CAAC,CAqEjB"}

package/dist/cli.js

@@ -1,10 +1,11 @@
-import { readFile, realpath, writeFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
 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 { buildExpectedManagedGuidanceBlock, buildGuidanceFileContent, buildGuidanceRevision, extractManagedGuidanceBlock, GUIDANCE_TARGETS, normalizeGuidanceTargets, } from "./guidance.js";
 import { createPromptApi } from "./prompts.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";
@@ -492,7 +493,9 @@ function printMainHelp(runtime) {
         "  init",
         "  corner use",
         "  whoami",
+        "  agent start|checkpoint|intent|end",
         "  workstream (ws) list|use|current|create|pull|update|push|question|attach|reply-thread",
+        "  open [--workstream <id>] [--corner <slug>]",
         "  help",
         "  version",
         "",
@@ -663,6 +666,29 @@ function mergeCommonOptions(base, values) {
 async function requireStoredProfile(runtime, common) {
     const selected = await runtime.config.getProfile(common.profile ?? null);
     if (!selected) {
+        // Fallback: try reading the desktop app's auth token
+        const desktopToken = await runtime.config.getDesktopToken();
+        if (desktopToken) {
+            const apiUrl = common.apiUrl ?? desktopToken.apiUrl;
+            const desktopProfile = {
+                apiUrl,
+                accessToken: desktopToken.accessToken,
+                sessionId: null,
+                workspace: desktopToken.workspace,
+                accountId: null,
+                userId: null,
+                handle: null,
+                createdAt: new Date().toISOString(),
+            };
+            return {
+                profileName: "desktop",
+                profile: desktopProfile,
+                client: runtime.createClient({
+                    apiUrl,
+                    accessToken: desktopToken.accessToken,
+                }),
+            };
+        }
         throw new CLIError("Not logged in. Run `corners auth login` first.", {
             json: common.json,
         });
@@ -716,6 +742,34 @@ async function maybeRefreshStoredProfileIdentity(input) {
 async function resolveAuthStatus(runtime, common) {
     const selected = await runtime.config.getProfile(common.profile ?? null);
     if (!selected) {
+        // Fallback: check desktop app's auth token
+        const desktopToken = await runtime.config.getDesktopToken();
+        if (desktopToken) {
+            const apiUrl = common.apiUrl ?? desktopToken.apiUrl;
+            const client = runtime.createClient({
+                apiUrl,
+                accessToken: desktopToken.accessToken,
+            });
+            let remote;
+            try {
+                remote = await client.validateSession();
+            }
+            catch (error) {
+                remote = { valid: false, error: error.message };
+            }
+            return {
+                loggedIn: true,
+                profile: "desktop (via Corners app)",
+                apiUrl,
+                sessionId: null,
+                workspace: desktopToken.workspace,
+                handle: remote.valid ? null : null,
+                accountId: null,
+                userId: null,
+                remoteValid: remote.valid,
+                remoteError: remote.valid ? null : (remote.error ?? null),
+            };
+        }
         return {
             loggedIn: false,
             profile: common.profile ?? null,
@@ -898,21 +952,41 @@ async function resolveGuidanceState(root) {
         files,
     };
 }
-function buildGuidanceWarning(guidance) {
+/**
+ * Silently syncs stale guidance files and updates config.
+ * Called automatically from resolveRootContext() so users never need to run `guidance sync` manually.
+ */
+async function autoSyncGuidanceIfStale(root, guidance, writeConfig) {
     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}\`.`;
+        return { root, guidance };
+    }
+    const managedTargets = root.config.guidance?.managedTargets !== undefined
+        ? normalizeGuidanceTargets(root.config.guidance.managedTargets)
+        : guidance.managedTargets;
+    const edits = [];
+    for (const target of GUIDANCE_TARGETS) {
+        if (!managedTargets.includes(target.key))
+            continue;
+        const targetPath = join(root.rootDir, target.relativePath);
+        const nextContent = buildGuidanceFileContent(target.key, await readOptionalUtf8(targetPath));
+        const edit = await buildPlannedEdit(targetPath, nextContent);
+        if (edit)
+            edits.push(edit);
+    }
+    if (edits.length > 0) {
+        await writePlannedEdits(edits);
+    }
+    const nextConfig = withUpdatedGuidanceConfig(root.config, managedTargets, toIsoString());
+    await writeConfig(root.rootDir, nextConfig);
+    const nextRoot = { ...root, config: nextConfig };
+    const nextGuidance = await resolveGuidanceState(nextRoot);
+    return { root: nextRoot, guidance: nextGuidance };
 }
 function buildGuidanceJsonMetadata(guidance) {
     return {
         stale: guidance.stale,
         lastSyncedAt: guidance.lastSyncedAt,
         staleFiles: guidance.staleFiles,
-        syncCommand: GUIDANCE_SYNC_COMMAND,
     };
 }
 function withGuidanceJsonMetadata(payload, guidance) {
@@ -926,26 +1000,21 @@ function withGuidanceJsonMetadata(payload, guidance) {
         },
     };
 }
-async function resolveRootContext(runtime, common, root, options) {
+async function resolveRootContext(runtime, _common, root) {
     const guidance = await resolveGuidanceState(root);
-    if ((options?.emitWarning ?? true) && !common.json) {
-        const warning = buildGuidanceWarning(guidance);
-        if (warning) {
-            printLine(runtime.stderr, warning);
-        }
-    }
-    await syncSkillsIfNeeded(root.rootDir, root.config, (dir, cfg) => runtime.config.writeLocalConfig(dir, cfg));
+    const synced = await autoSyncGuidanceIfStale(root, guidance, (dir, cfg) => runtime.config.writeLocalConfig(dir, cfg));
+    await syncSkillsIfNeeded(synced.root.rootDir, synced.root.config, (dir, cfg) => runtime.config.writeLocalConfig(dir, cfg));
     return {
-        root,
-        guidance,
+        root: synced.root,
+        guidance: synced.guidance,
     };
 }
-async function requireLocalRoot(runtime, common, options) {
+async function requireLocalRoot(runtime, common) {
     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);
+    return resolveRootContext(runtime, common, root);
 }
 async function requirePinnedRootProfile(runtime, common, rootContext) {
     const { root, guidance } = rootContext;
@@ -1489,17 +1558,88 @@ async function handleInit(args, runtime, inherited) {
             }
             await writePlannedEdits(plannedEdits);
         }
+        // --- Claude Code Settings Hook ---
+        if (selectedTargets.some((t) => t.key === "claude")) {
+            const claudeSettingsPath = join(rootDir, ".claude", "settings.json");
+            try {
+                await mkdir(join(rootDir, ".claude"), { recursive: true });
+                let existing = {};
+                try {
+                    const raw = await readOptionalUtf8(claudeSettingsPath);
+                    if (raw) {
+                        existing = JSON.parse(raw);
+                    }
+                }
+                catch {
+                    // Malformed JSON — start fresh
+                    existing = {};
+                }
+                // Merge permissions.allow
+                const existingPerms = existing.permissions ?? {};
+                const existingAllow = Array.isArray(existingPerms.allow)
+                    ? existingPerms.allow
+                    : [];
+                const newPerms = [
+                    "Bash(corners workstream:*)",
+                    "Bash(corners agent:*)",
+                ];
+                const mergedAllow = [
+                    ...existingAllow,
+                    ...newPerms.filter((p) => !existingAllow.includes(p)),
+                ];
+                // Merge hooks.SessionStart
+                const existingHooks = existing.hooks ?? {};
+                const existingSessionStart = Array.isArray(existingHooks.SessionStart)
+                    ? existingHooks.SessionStart
+                    : [];
+                const hookCommand = "command -v corners >/dev/null 2>&1 && corners workstream current --json || true";
+                const alreadyHasHook = existingSessionStart.some((entry) => Array.isArray(entry.hooks) &&
+                    entry.hooks.some((h) => h.command === hookCommand));
+                const mergedSessionStart = alreadyHasHook
+                    ? existingSessionStart
+                    : [
+                        ...existingSessionStart,
+                        {
+                            matcher: "",
+                            hooks: [{ type: "command", command: hookCommand }],
+                        },
+                    ];
+                const merged = {
+                    ...existing,
+                    permissions: {
+                        ...existingPerms,
+                        allow: mergedAllow,
+                    },
+                    hooks: {
+                        ...existingHooks,
+                        SessionStart: mergedSessionStart,
+                    },
+                };
+                await writeFile(claudeSettingsPath, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+                if (!common.json) {
+                    printLine(runtime.stderr, "  Wrote Claude Code settings with SessionStart hook");
+                }
+            }
+            catch (error) {
+                if (!common.json) {
+                    printLine(runtime.stderr, `  Warning: could not write .claude/settings.json: ${error.message}`);
+                }
+            }
+        }
         // --- Agent Communication Setup ---
         const setupAgentComms = await prompts.confirm("Set up agent communication? (auto-connect workstream + CLAUDE.md instructions)", { defaultValue: true });
         let connectedWorkstream = null;
         if (setupAgentComms) {
             // Auto-connect or create a workstream
-            const workstreams = await client.graphql(`query CliInitWorkstreams($cornerId: ID!) {
+            const workstreams = await client
+                .graphql(`query CliInitWorkstreams($cornerId: ID!) {
           corner(id: $cornerId) { workstreams(first: 20) { edges { node { id name status } } } }
-        }`, { cornerId: defaultCorner.id }).then((r) => {
+        }`, { cornerId: defaultCorner.id })
+                .then((r) => {
                 const corner = r.corner;
                 return corner?.workstreams?.edges?.map((e) => e.node) ?? [];
-            }).catch(() => []);
+            })
+                .catch(() => []);
             if (workstreams.length > 0) {
                 const wsChoice = await prompts.select("Connect a workstream for agent updates:", [
                     ...workstreams.map((ws) => ({
@@ -1515,7 +1655,9 @@ async function handleInit(args, runtime, inherited) {
                     connectedWorkstream = created.createWorkstream;
                 }
                 else if (wsChoice !== "__skip__") {
-                    connectedWorkstream = workstreams.find((ws) => ws.id === wsChoice) ?? null;
+                    connectedWorkstream =
+                        workstreams.find((ws) => ws.id === wsChoice) ??
+                            null;
                 }
             }
             else {
@@ -1536,22 +1678,8 @@ async function handleInit(args, runtime, inherited) {
                 const updatedConfigPath = runtime.config.getLocalConfigPath(rootDir);
                 await writeFile(updatedConfigPath, `${JSON.stringify(nextLocalConfig, null, 2)}\n`, "utf8");
             }
-            // Write CLAUDE.md agent instructions
-            const claudeMdPath = join(rootDir, "CLAUDE.md");
-            const existingClaudeMd = await readOptionalUtf8(claudeMdPath);
-            const agentSection = `\n## Agent Communication\n\nWhen working on tasks, report progress to the team through Corners:\n- At the start: \`corners workstream push --type session_start --intent "description" --json\`\n- At natural checkpoints: \`corners workstream push --type checkpoint --message "what you did" --files "file1,file2" --json\`\n- When done: \`corners workstream push --type session_end --summary "what was accomplished" --json\`\n`;
-            if (existingClaudeMd && !existingClaudeMd.includes("## Agent Communication")) {
-                await writeFile(claudeMdPath, existingClaudeMd + agentSection, "utf8");
-                if (!common.json) {
-                    printLine(runtime.stderr, "  Added agent communication instructions to CLAUDE.md");
-                }
-            }
-            else if (!existingClaudeMd) {
-                await writeFile(claudeMdPath, `# ${basename(rootDir)}\n${agentSection}`, "utf8");
-                if (!common.json) {
-                    printLine(runtime.stderr, "  Created CLAUDE.md with agent communication instructions");
-                }
-            }
+            // Agent communication instructions are now part of the managed guidance
+            // block in buildGuidanceSection(). No separate append needed.
             // Send test checkpoint
             if (connectedWorkstream) {
                 try {
@@ -1591,7 +1719,7 @@ async function handleInit(args, runtime, inherited) {
             const wsMsg = connectedWorkstream
                 ? ` Connected workstream: ${connectedWorkstream.name}.`
                 : "";
-            printLine(runtime.stdout, `Initialized Corners CLI at ${rootDir} with default corner ${defaultCorner.name}.${wsMsg} Run \`${GUIDANCE_SYNC_COMMAND}\` later to refresh managed guidance.`);
+            printLine(runtime.stdout, `Initialized Corners CLI at ${rootDir} with default corner ${defaultCorner.name}.${wsMsg}`);
         }
         return 0;
     });
@@ -1655,9 +1783,7 @@ async function handleSkills(args, runtime, inherited) {
                 printSkillsHelp(runtime);
                 return 0;
             }
-            const rootContext = await requireLocalRoot(runtime, common, {
-                emitWarning: false,
-            });
+            const rootContext = await requireLocalRoot(runtime, common);
             const state = await resolveSkillsState(rootContext.root.rootDir, rootContext.root.config);
             const payload = {
                 ok: true,
@@ -1713,9 +1839,7 @@ async function handleGuidance(args, runtime, inherited) {
                 printGuidanceHelp(runtime);
                 return 0;
             }
-            const rootContext = await requireLocalRoot(runtime, common, {
-                emitWarning: false,
-            });
+            const rootContext = await requireLocalRoot(runtime, common);
             const payload = {
                 ok: true,
                 root: rootContext.root.rootDir,
@@ -1751,9 +1875,7 @@ async function handleGuidance(args, runtime, inherited) {
                 printGuidanceHelp(runtime);
                 return 0;
             }
-            const rootContext = await requireLocalRoot(runtime, common, {
-                emitWarning: false,
-            });
+            const rootContext = await requireLocalRoot(runtime, common);
             const managedTargets = rootContext.root.config.guidance?.managedTargets !== undefined
                 ? normalizeGuidanceTargets(rootContext.root.config.guidance.managedTargets)
                 : rootContext.guidance.managedTargets;
@@ -1871,6 +1993,167 @@ async function handleCorner(args, runtime, inherited) {
             throw new CLIError(`Unknown corner command: ${subcommand}`);
     }
 }
+function printAgentHelp(runtime) {
+    printLine(runtime.stdout, [
+        "corners agent",
+        "",
+        "Usage:",
+        "  corners agent start [--intent <text>] [--json]",
+        "  corners agent checkpoint --message <text> [--files <paths>] [--json]",
+        "  corners agent intent --scope <text> [--files <paths>] [--json]",
+        "  corners agent end [--summary <text>] [--json]",
+        "",
+        "Thin wrappers over workstream push for agent session lifecycle.",
+        "Auto-creates a workstream if none is active.",
+    ].join("\n"));
+}
+function resolveGitBranch() {
+    try {
+        return (execSync("git branch --show-current", {
+            encoding: "utf8",
+            timeout: 3000,
+        }).trim() || "unknown");
+    }
+    catch {
+        return "unknown";
+    }
+}
+async function resolveAgentWorkstreamId(runtime, common, client) {
+    // Try the normal resolution first (explicit flag or binding)
+    const binding = await runtime.config.getBinding(runtime.cwd);
+    if (binding) {
+        return binding.workstreamId;
+    }
+    // Auto-create a workstream named after the git branch
+    const root = await runtime.config.findLocalRoot(runtime.cwd);
+    if (!root) {
+        throw new CLIError("No Corners root found. Run `corners init` first.", {
+            json: common.json,
+        });
+    }
+    const branch = resolveGitBranch();
+    const wsName = `agent/${branch}`;
+    const result = await client.graphql(`mutation CliAgentAutoCreate($input: CreateWorkstreamInput!) { createWorkstream(input: $input) { id name } }`, { input: { cornerId: root.config.defaultCorner.id, name: wsName } });
+    // Bind the auto-created workstream so future commands use it
+    await runtime.config.setBinding(runtime.cwd, {
+        profile: root.config.profile,
+        workspace: root.config.workspace ?? "",
+        workstreamId: result.createWorkstream.id,
+        cornerId: root.config.defaultCorner.id,
+        boundAt: toIsoString(),
+    });
+    if (!common.json) {
+        printLine(runtime.stderr, `Auto-created workstream "${wsName}" (${result.createWorkstream.id})`);
+    }
+    return result.createWorkstream.id;
+}
+async function handleAgent(args, runtime, inherited) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help") {
+        printAgentHelp(runtime);
+        return 0;
+    }
+    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" },
+            message: { type: "string" },
+            intent: { type: "string" },
+            summary: { type: "string" },
+            scope: { type: "string" },
+            files: { type: "string" },
+        },
+    });
+    const common = mergeCommonOptions(inherited, {
+        json: parsed.values.json,
+        profile: parsed.values.profile,
+        apiUrl: parsed.values["api-url"],
+    });
+    if (parsed.values.help) {
+        printAgentHelp(runtime);
+        return 0;
+    }
+    // Resolve update type and synthesize message from subcommand-specific flags
+    let updateType;
+    let message;
+    switch (subcommand) {
+        case "start":
+            updateType = "session_start";
+            message = parsed.values.intent ?? "session started";
+            break;
+        case "checkpoint":
+            updateType = "checkpoint";
+            message = parsed.values.message ?? "";
+            if (!message) {
+                throw new CLIError("Checkpoint needs a message. Use --message.", {
+                    json: common.json,
+                });
+            }
+            break;
+        case "intent":
+            updateType = "intent";
+            message = parsed.values.scope ?? "";
+            if (!message) {
+                throw new CLIError("Intent needs a scope. Use --scope.", {
+                    json: common.json,
+                });
+            }
+            break;
+        case "end":
+            updateType = "session_end";
+            message = parsed.values.summary ?? "session ended";
+            break;
+        default:
+            throw new CLIError(`Unknown agent command: ${subcommand}`, {
+                json: common.json,
+            });
+    }
+    const { guidance, client } = await requireCommandProfile(runtime, common);
+    // Resolve workstream with auto-create fallback
+    const workstreamId = parsed.values.workstream
+        ? parsed.values.workstream
+        : await resolveAgentWorkstreamId(runtime, common, client);
+    const workstream = await resolveExplicitWorkstream(client, common, workstreamId);
+    // Detect agent type from environment
+    const agentType = (process.env.CLAUDE_CODE ? "claude-code" : null) ??
+        (process.env.CODEX_SESSION ? "codex" : null) ??
+        null;
+    const filesTouched = parsed.values.files
+        ? parsed.values.files.split(",").map((f) => f.trim())
+        : null;
+    const scope = parsed.values.scope ?? null;
+    const updateResult = await client.graphql(RECORD_WORKSTREAM_UPDATE_MUTATION, {
+        input: {
+            workstreamId: workstream.id,
+            updateType: toGraphQLWorkstreamUpdateType(updateType),
+            content: message,
+            summary: parsed.values.summary,
+            ...(agentType ? { agentType } : {}),
+            ...(filesTouched ? { filesTouched } : {}),
+            ...(scope ? { scope } : {}),
+        },
+    });
+    const payload = {
+        ok: true,
+        success: true,
+        workstreamId: workstream.id,
+        type: updateType,
+        messageId: updateResult.recordWorkstreamUpdate.id,
+        update: updateResult.recordWorkstreamUpdate,
+    };
+    if (common.json) {
+        printJson(runtime.stdout, withGuidanceJsonMetadata(payload, guidance));
+    }
+    else {
+        printLine(runtime.stdout, `Recorded agent ${subcommand} on ${workstream.id}.`);
+    }
+    return 0;
+}
 async function handleWorkstream(args, runtime, inherited) {
     const subcommand = args[0];
     if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -2768,6 +3051,50 @@ async function handleWorkstream(args, runtime, inherited) {
             throw new CLIError(`Unknown workstream command: ${subcommand}`);
     }
 }
+async function handleOpen(args, runtime) {
+    const parsed = parseArgs({
+        args,
+        allowPositionals: false,
+        options: {
+            workstream: { type: "string", short: "w" },
+            corner: { type: "string", short: "c" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    if (parsed.values.help) {
+        printLine(runtime.stdout, [
+            "corners open",
+            "",
+            "Open the Corners desktop app, optionally navigating to a specific workstream or corner.",
+            "",
+            "Usage:",
+            "  corners open [--workstream <id>] [--corner <slug>]",
+            "",
+            "Options:",
+            "  --workstream, -w <id>    Open to a specific workstream",
+            "  --corner, -c <slug>      Open to a specific corner",
+            "  --help, -h               Show this help",
+            "",
+            "Examples:",
+            "  corners open",
+            "  corners open --workstream ws_abc123",
+            "  corners open --corner engineering",
+        ].join("\n"));
+        return 0;
+    }
+    let url = "corners://";
+    if (parsed.values.workstream) {
+        url = `corners://open?workstream=${encodeURIComponent(parsed.values.workstream)}`;
+    }
+    else if (parsed.values.corner) {
+        url = `corners://open?corner=${encodeURIComponent(parsed.values.corner)}`;
+    }
+    const opened = await openUrlInBrowser(url);
+    if (!opened) {
+        throw new CLIError("Could not open the Corners desktop app. Is it installed?");
+    }
+    return 0;
+}
 async function handleMcp(args, runtime, inherited) {
     const subcommand = args[0];
     if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -2855,11 +3182,15 @@ export async function runCli(argv, runtime = createRuntime()) {
             return handleCorner(parsed.rest.slice(1), runtime, parsed.common);
         case "whoami":
             return handleWhoAmI(parsed.rest.slice(1), runtime, parsed.common);
+        case "agent":
+            return handleAgent(parsed.rest.slice(1), runtime, parsed.common);
         case "workstream":
         case "ws":
             return handleWorkstream(parsed.rest.slice(1), runtime, parsed.common);
         case "mcp":
             return handleMcp(parsed.rest.slice(1), runtime, parsed.common);
+        case "open":
+            return handleOpen(parsed.rest.slice(1), runtime);
         default:
             throw new CLIError(`Unknown command: ${command}`, {
                 json: parsed.common.json,