@almanak/mcp-server 0.2.1 → 0.2.3

package/dist/tools.js

@@ -49,6 +49,8 @@ exports.PlatformToolHandler = void 0;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const runner_1 = require("./testing/runner");
+const workspace_git_1 = require("./workspace-git");
+const EXPORT_COMMIT_MESSAGE = 'feat: initial strategy export from Almanak';
 const ROOT_DIR_ALLOWED_RE = /^[a-zA-Z0-9._/-]+$/;
 const WORKSPACE_ABSOLUTE_PATH_RE = /^\/(?:tmp\/)?workspaces\/[^/]+\/(.+)$/;
 const WORKSPACE_ROOT_PATH_RE = /^\/(?:tmp\/)?workspaces\/[^/]+\/?$/;
@@ -196,6 +198,7 @@ class PlatformToolHandler {
             disabledTools: [],
             sdkGeneration: undefined,
             testController: null,
+            workspaceRoot: undefined,
             ...options,
         };
         this.enabledModes = new Set(this.options.modes);
@@ -255,7 +258,7 @@ class PlatformToolHandler {
      * is unavailable. Best effort by design: a failed check must never block the export flow.
      */
     async getLinkedSessionRepo() {
-        var _a;
+        var _a, _b;
         try {
             const response = await this.client.getSessionRepoLink();
             const data = ((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response);
@@ -265,19 +268,317 @@ class PlatformToolHandler {
             const repoName = typeof data.repoName === 'string' ? data.repoName : '';
             if (!repoOwner || !repoName)
                 return null;
+            const str = (key) => (typeof data[key] === 'string' ? data[key] : null);
             return {
                 repoOwner,
                 repoName,
                 // The backend URL is provider-aware (Almanak Git or GitHub) — never assume a github.com host here.
-                repoUrl: typeof data.repoUrl === 'string' ? data.repoUrl : '',
-                provider: typeof data.provider === 'string' ? data.provider : null,
-                strategyLinkId: typeof data.strategyLinkId === 'string' ? data.strategyLinkId : null,
+                repoUrl: (_b = str('repoUrl')) !== null && _b !== void 0 ? _b : '',
+                provider: str('provider'),
+                strategyLinkId: str('strategyLinkId'),
+                repoId: str('repoId'),
+                cloneUrl: str('cloneUrl'),
+                gitHost: str('gitHost'),
+                defaultBranch: str('defaultBranch'),
             };
         }
         catch {
             return null;
         }
     }
+    /** Workspace root for git-backed tools (see ToolHandlerOptions.workspaceRoot). */
+    get workspaceRoot() {
+        var _a;
+        return (_a = this.options.workspaceRoot) !== null && _a !== void 0 ? _a : process.cwd();
+    }
+    gitOpts(sessionId, timeoutMs) {
+        return { cwd: this.workspaceRoot, sessionId, ...(timeoutMs !== undefined ? { timeoutMs } : {}) };
+    }
+    /**
+     * Map a failed `POST /agent-sessions/{id}/repository` response to the tool's status vocabulary.
+     * Returns null when the response is a success.
+     */
+    mapLinkFailure(res) {
+        if (res && res.valid !== false && !(typeof res.statusCode === 'number' && res.statusCode >= 400) && res.data)
+            return null;
+        const message = typeof (res === null || res === void 0 ? void 0 : res.error) === 'string' ? res.error : typeof (res === null || res === void 0 ? void 0 : res.message) === 'string' ? res.message : 'Repository link failed';
+        const code = typeof (res === null || res === void 0 ? void 0 : res.errorCode) === 'string' ? res.errorCode : null;
+        switch (code) {
+            case 'name_conflict':
+                return { status: 'name_conflict', message: `${message} Choose a different repoName and call the tool again.` };
+            case 'github_connection_required':
+                return { status: 'github_connection_required', message };
+            case 'provider_disabled':
+                return { status: 'provider_disabled', message };
+            case 'repo_config_in_progress':
+                return { status: 'in_progress', message: `${message} Another link operation is still running for this session; wait and retry.` };
+            default:
+                return { status: 'failed', statusCode: typeof (res === null || res === void 0 ? void 0 : res.statusCode) === 'number' ? res.statusCode : 502, error: message, ...(code ? { errorCode: code } : {}) };
+        }
+    }
+    /**
+     * strategies_export_workspace: create + link a new repository, then init/commit/push the
+     * workspace from inside this call. Every step is synchronous so the agent can continue in
+     * the same turn on `completed`.
+     */
+    async exportWorkspace(args) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const repoName = typeof args.repoName === 'string' ? args.repoName.trim() : '';
+        if (!repoName)
+            return { statusCode: 400, status: 'failed', error: 'repoName is required' };
+        const description = typeof args.description === 'string' && args.description.trim() ? args.description.trim() : undefined;
+        let rootDir;
+        try {
+            rootDir = normalizeExportRootDir(args.rootDir);
+        }
+        catch (err) {
+            return { status: 'preflight_failed', message: (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err) };
+        }
+        // a. A chat links to exactly one repository — never create a second one.
+        const linked = await this.getLinkedSessionRepo();
+        if (linked)
+            return this.alreadyLinkedResult(linked);
+        const sessionId = this.client.sessionId();
+        if (!sessionId) {
+            return { statusCode: 400, status: 'failed', error: 'The platform token carries no agentSessionId claim; this tool only works inside an Almanak Code session.' };
+        }
+        const cwd = this.workspaceRoot;
+        // b. Flatten rootDir into the workspace root so the repository is flat.
+        if (rootDir) {
+            const flat = await (0, workspace_git_1.flattenRootDir)(cwd, rootDir);
+            if (!flat.ok)
+                return { status: 'preflight_failed', message: flat.error };
+        }
+        // c. Something must survive the export skip rules before we create a repository.
+        if (!(await (0, workspace_git_1.hasExportableFiles)(cwd))) {
+            return {
+                status: 'preflight_failed',
+                message: 'No exportable files in the workspace (session-internal, env, dependency and cache files are excluded). Create the strategy files first, then retry.',
+            };
+        }
+        // d. Create + link the repository (the backend also provisions git credentials for this session).
+        const res = await this.client.linkSessionRepository(sessionId, { create: { repoName, description } });
+        const failure = this.mapLinkFailure(res);
+        if (failure)
+            return failure;
+        const link = res.data;
+        if (link.status === 'already_linked') {
+            // Lost a race with another link in this session: surface it, never push to a repository we did not just create.
+            return this.alreadyLinkedResult({
+                repoOwner: link.repoOwner,
+                repoName: link.repoName,
+                repoUrl: link.repoUrl,
+                provider: (_b = link.provider) !== null && _b !== void 0 ? _b : null,
+                strategyLinkId: (_c = link.strategyLinkId) !== null && _c !== void 0 ? _c : null,
+                repoId: (_d = link.repoId) !== null && _d !== void 0 ? _d : null,
+                cloneUrl: (_e = link.cloneUrl) !== null && _e !== void 0 ? _e : null,
+                gitHost: (_f = link.gitHost) !== null && _f !== void 0 ? _f : null,
+                defaultBranch: (_g = link.defaultBranch) !== null && _g !== void 0 ? _g : null,
+            });
+        }
+        const defaultBranch = link.defaultBranch || 'main';
+        const linkedFields = {
+            provider: link.provider,
+            repoOwner: link.repoOwner,
+            repoName: link.repoName,
+            repoUrl: link.repoUrl,
+            strategyLinkId: link.strategyLinkId,
+            cloneUrl: link.cloneUrl,
+        };
+        // e. git, in the workspace, with ALMANAK_SESSION_ID for the credential helper.
+        const opts = this.gitOpts(sessionId);
+        let branch = defaultBranch;
+        // Always land the export on the repository's default branch: backtests and deploys resolve that
+        // branch, so a workspace already on another local branch pushes there via an explicit refspec.
+        const pushRefspec = (b) => (b === defaultBranch ? b : `${b}:${defaultBranch}`);
+        const pushHint = (b) => `Repository is linked; fix the problem and run: git push -u origin ${pushRefspec(b)}`;
+        try {
+            if (!(await (0, workspace_git_1.isGitRepo)(cwd))) {
+                await (0, workspace_git_1.initRepo)(defaultBranch, opts);
+            }
+            else {
+                const existing = await (0, workspace_git_1.currentBranch)(opts);
+                if (existing) {
+                    branch = existing;
+                }
+                else if (!(await (0, workspace_git_1.hasCommits)(opts))) {
+                    // Unborn HEAD with a different name: rename it before the first commit.
+                    await (0, workspace_git_1.runGit)(['symbolic-ref', 'HEAD', `refs/heads/${defaultBranch}`], opts);
+                }
+                else {
+                    await (0, workspace_git_1.runGit)(['checkout', '-B', defaultBranch], opts);
+                }
+            }
+            await (0, workspace_git_1.ensureManagedExcludes)(cwd);
+            await (0, workspace_git_1.ensureCommitIdentity)(opts);
+            await (0, workspace_git_1.ensureOriginRemote)(link.cloneUrl, opts);
+            await (0, workspace_git_1.runGit)(['add', '-A'], opts);
+            const nothingStaged = await (0, workspace_git_1.gitSucceeds)(['diff', '--cached', '--quiet'], opts);
+            if (nothingStaged && !(await (0, workspace_git_1.hasCommits)(opts))) {
+                return {
+                    status: 'preflight_failed',
+                    ...linkedFields,
+                    message: 'No exportable files: everything in the workspace is ignored by git (.gitignore or the managed excludes). ' +
+                        `The repository ${link.repoOwner}/${link.repoName} is linked but empty — add files and run: git add -A && git commit -m "..." && git push -u origin ${branch}`,
+                };
+            }
+            if (!nothingStaged)
+                await (0, workspace_git_1.runGit)(['commit', '-q', '-m', EXPORT_COMMIT_MESSAGE], opts);
+        }
+        catch (err) {
+            return this.linkedPushFailed(err, linkedFields, branch, pushHint(branch));
+        }
+        try {
+            await (0, workspace_git_1.runGit)(['push', '-u', 'origin', pushRefspec(branch)], this.gitOpts(sessionId, workspace_git_1.GIT_NETWORK_TIMEOUT_MS));
+        }
+        catch (err) {
+            return this.linkedPushFailed(err, linkedFields, branch, pushHint(branch));
+        }
+        const commitSha = (await (0, workspace_git_1.runGit)(['rev-parse', 'HEAD'], opts)).stdout.trim();
+        // f. Done — the agent continues in the same turn.
+        return {
+            status: 'completed',
+            provider: link.provider,
+            repoOwner: link.repoOwner,
+            repoName: link.repoName,
+            repoUrl: link.repoUrl,
+            strategyLinkId: link.strategyLinkId,
+            commitSha,
+            branch: defaultBranch,
+            ...(branch !== defaultBranch ? { localBranch: branch } : {}),
+            message: `Exported and pushed ${commitSha.slice(0, 8)} to ${link.repoOwner}/${link.repoName} (${defaultBranch}). ` +
+                (branch !== defaultBranch
+                    ? `The workspace stays on its local branch ${branch}, which tracks origin/${defaultBranch}. `
+                    : '') +
+                'The workspace is now a git checkout of this repository.',
+        };
+    }
+    alreadyLinkedResult(linked) {
+        return {
+            status: 'already_linked',
+            repoOwner: linked.repoOwner,
+            repoName: linked.repoName,
+            repoUrl: linked.repoUrl,
+            strategyLinkId: linked.strategyLinkId,
+            provider: linked.provider,
+            ...(linked.cloneUrl ? { cloneUrl: linked.cloneUrl } : {}),
+            ...(linked.defaultBranch ? { defaultBranch: linked.defaultBranch } : {}),
+            message: `This chat is already linked to ${linked.repoOwner}/${linked.repoName}. ` +
+                'Exporting again is not possible from this chat — use git add/commit/push in the workspace to publish further changes.',
+        };
+    }
+    linkedPushFailed(err, linkedFields, branch, hint) {
+        var _a;
+        const raw = err instanceof workspace_git_1.GitError ? err.message : (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err);
+        return {
+            status: 'linked_push_failed',
+            error: (0, workspace_git_1.redactSecrets)(raw),
+            ...linkedFields,
+            branch,
+            message: hint,
+        };
+    }
+    /**
+     * strategies_link_workspace: attach the chat to an existing strategy link and wire the
+     * workspace to its repository with git (clone into an empty workspace, or fetch + new branch
+     * when user files exist so nothing is overwritten).
+     */
+    async linkWorkspace(args) {
+        var _a;
+        const strategyLinkId = typeof args.strategy_link_id === 'string' ? args.strategy_link_id.trim() : '';
+        if (!strategyLinkId)
+            return { statusCode: 400, status: 'failed', error: 'strategy_link_id is required' };
+        const sessionId = this.client.sessionId();
+        if (!sessionId) {
+            return { statusCode: 400, status: 'failed', error: 'The platform token carries no agentSessionId claim; this tool only works inside an Almanak Code session.' };
+        }
+        const cwd = this.workspaceRoot;
+        const res = await this.client.linkSessionRepository(sessionId, { strategyLinkId });
+        const failure = this.mapLinkFailure(res);
+        if (failure)
+            return failure;
+        const link = res.data;
+        const defaultBranch = link.defaultBranch || 'main';
+        const base = {
+            provider: link.provider,
+            repoId: link.repoId,
+            repoOwner: link.repoOwner,
+            repoName: link.repoName,
+            repoUrl: link.repoUrl,
+            cloneUrl: link.cloneUrl,
+            strategyLinkId: link.strategyLinkId,
+            defaultBranch,
+        };
+        if (link.status === 'already_linked' && link.strategyLinkId && link.strategyLinkId !== strategyLinkId) {
+            return {
+                status: 'already_linked',
+                ...base,
+                branch: null,
+                message: `This chat is already linked to ${link.repoOwner}/${link.repoName} (strategy link ${link.strategyLinkId}); it cannot be relinked to ${strategyLinkId}. Workspace git was left untouched.`,
+            };
+        }
+        const opts = this.gitOpts(sessionId);
+        const netOpts = this.gitOpts(sessionId, workspace_git_1.GIT_NETWORK_TIMEOUT_MS);
+        try {
+            if (await (0, workspace_git_1.isGitRepo)(cwd)) {
+                await (0, workspace_git_1.ensureOriginRemote)(link.cloneUrl, opts);
+                await (0, workspace_git_1.ensureManagedExcludes)(cwd);
+                const branch = await (0, workspace_git_1.currentBranch)(opts);
+                return {
+                    status: link.status,
+                    ...base,
+                    branch,
+                    message: `Linked ${link.repoOwner}/${link.repoName}; the workspace was already a git repository, so only the origin remote was repointed to it. Run git fetch origin and reconcile with origin/${defaultBranch} as needed.`,
+                };
+            }
+            const userFiles = await (0, workspace_git_1.hasUserFiles)(cwd);
+            await (0, workspace_git_1.initRepo)(defaultBranch, opts);
+            await (0, workspace_git_1.ensureManagedExcludes)(cwd);
+            await (0, workspace_git_1.ensureCommitIdentity)(opts);
+            await (0, workspace_git_1.ensureOriginRemote)(link.cloneUrl, opts);
+            await (0, workspace_git_1.runGit)(['fetch', '-q', 'origin'], netOpts);
+            const remoteHasBranch = await (0, workspace_git_1.remoteBranchExists)(defaultBranch, opts);
+            if (!userFiles) {
+                if (remoteHasBranch) {
+                    await (0, workspace_git_1.runGit)(['checkout', '-q', '-B', defaultBranch, `origin/${defaultBranch}`], opts);
+                    return {
+                        status: link.status,
+                        ...base,
+                        branch: defaultBranch,
+                        message: `Linked ${link.repoOwner}/${link.repoName} and checked out origin/${defaultBranch} into the workspace.`,
+                    };
+                }
+                return {
+                    status: link.status,
+                    ...base,
+                    branch: defaultBranch,
+                    message: `Linked ${link.repoOwner}/${link.repoName}; the repository has no ${defaultBranch} branch yet, so the workspace is an empty checkout on ${defaultBranch}. Add files, commit, and git push -u origin ${defaultBranch}.`,
+                };
+            }
+            const sessionBranch = `almanak/session-${sessionId.replace(/[^a-zA-Z0-9-]/g, '').slice(0, 8)}`;
+            await (0, workspace_git_1.runGit)(['symbolic-ref', 'HEAD', `refs/heads/${sessionBranch}`], opts);
+            return {
+                status: link.status,
+                ...base,
+                branch: sessionBranch,
+                message: `Linked ${link.repoOwner}/${link.repoName}. The workspace already had files, so they were NOT overwritten: git was initialised on new branch ${sessionBranch} ` +
+                    `with the existing files left as uncommitted changes` +
+                    (remoteHasBranch
+                        ? ` and origin/${defaultBranch} fetched. Reconcile with git diff origin/${defaultBranch}, then commit and push (git push -u origin ${sessionBranch}, or merge into ${defaultBranch}).`
+                        : `; the repository has no ${defaultBranch} branch yet. Commit and git push -u origin ${defaultBranch} when ready.`),
+            };
+        }
+        catch (err) {
+            const raw = err instanceof workspace_git_1.GitError ? err.message : (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err);
+            return {
+                status: 'linked_attach_failed',
+                error: (0, workspace_git_1.redactSecrets)(raw),
+                ...base,
+                branch: null,
+                message: `The chat is linked to ${link.repoOwner}/${link.repoName} but attaching the workspace with git failed; fix the problem and run git remote add origin ${link.cloneUrl} && git fetch origin manually.`,
+            };
+        }
+    }
     register(mode, definition, handler) {
         this.registeredNames.add(definition.name);
         if (!this.modeEnabled(mode))
@@ -331,7 +632,7 @@ class PlatformToolHandler {
                 type: 'object',
                 properties: {
                     agent_name: { type: 'string', description: 'Display name for the agent' },
-                    github_strategy_link_id: { type: 'string', description: 'ID of the linked strategy (from strategies_list or the export confirmation)' },
+                    github_strategy_link_id: { type: 'string', description: 'ID of the linked strategy (from strategies_list or the strategies_export_workspace result)' },
                     github_ref: { type: 'string', description: 'Git branch, tag, or commit SHA to deploy' },
                     github_ref_type: {
                         type: 'string',
@@ -863,92 +1164,56 @@ class PlatformToolHandler {
             return this.client.validateRepository(args.owner, args.repo, ref);
         });
         this.register('strategies', {
-            name: 'strategies_export_preview',
-            description: 'Show an interactive repo-export widget in the chat so the user can configure repo name, visibility, and other options before exporting. Showing this widget does NOT perform the export — the user must press the Export button in the widget. Only then does the export run and resume you with a confirmation result containing the new repo. Until you receive that confirmation result, do NOT claim the export completed, that the repo exists, or that the strategy is ready to deploy — the export has not happened yet. Don\'t ask if it finished or open another widget to confirm; just wait for the resume. If this chat is already linked to a repository, no widget is shown and the tool returns that repo instead (already_linked: true) — tell the user which repo it is; the export cannot be repeated in this chat.',
+            name: 'strategies_export_workspace',
+            description: 'Export the workspace to a NEW private repository on Almanak Git, the platform-hosted git service, created under the user namespace — there is no choice of git host. ' +
+                'Export the current workspace to a NEW git repository and link it to this chat, immediately, inside this tool call: ' +
+                'the platform creates and links the repository, then this tool runs git init/add/commit/push in the workspace itself. ' +
+                'No widget is shown and no user click is needed — on status "completed" the repository exists with the pushed commit, so ' +
+                'continue in the SAME turn (for example run a backtest or deploy). Pass repository metadata only; never read or submit files. ' +
+                'Session-internal files (.almanak, .almanakdb, almanak_state.db*, .env, .venv, node_modules, .logs) are excluded automatically. ' +
+                'Pass rootDir only when the strategy lives in a subfolder (e.g. "my_strategy/"): its contents are moved up to the workspace root ' +
+                'so the repository is flat. Statuses: "completed" (done: repoUrl, strategyLinkId, commitSha, branch); "already_linked" (this chat ' +
+                'already has a repository — do not export again, use git add/commit/push in the workspace); "name_conflict" (pick a different ' +
+                'repoName and retry); "preflight_failed" (fix the workspace/rootDir and retry); "github_connection_required", "provider_disabled", ' +
+                '"in_progress" (report to the user); "linked_push_failed" (the repository IS linked but the commit/push failed — fix the git ' +
+                'problem and run the git command in the message; do not call this tool again). Never claim the export succeeded before "completed".',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    strategyName: { type: 'string', description: 'Display name for the strategy (shown in widget header).' },
-                    repoName: { type: 'string', description: 'Suggested repository name (pre-fills the widget input, user can edit).' },
-                    description: { type: 'string', description: 'Suggested repository description (pre-fills the widget input, user can edit).' },
-                    rootDir: { type: 'string', description: 'Subdirectory within the workspace to use as the repo root. Pass this when the strategy was scaffolded into a subdirectory (e.g. almanak strat new creates my_strategy/). Omit for strategies at the workspace root (the default). Never pass an absolute path — workspace-relative folder name only. Files outside this dir are excluded and the prefix is stripped so the repo has a flat structure (my_strategy/strategy.py → strategy.py).' },
+                    repoName: { type: 'string', description: 'Repository name (required). Lowercase letters, digits, dashes recommended.' },
+                    description: { type: 'string', description: 'Repository description.' },
+                    rootDir: {
+                        type: 'string',
+                        description: 'Optional workspace-relative strategy folder whose contents become the repository root (flattened into the workspace). ' +
+                            'Omit for strategies at the workspace root (the default). Never pass an absolute path.',
+                    },
                 },
-                required: [],
+                required: ['repoName'],
             },
-        }, async (args) => {
-            var _a;
-            // A chat session links to exactly one repository. Opening the export widget on a session
-            // that is already linked can only end in a conflict — and, before the pre-check landed, a
-            // throwaway repo on the user's account (ALM-3262). Hand back the existing link instead.
-            const linkedRepo = await this.getLinkedSessionRepo();
-            if (linkedRepo) {
-                return {
-                    show_widget: false,
-                    already_linked: true,
-                    ...linkedRepo,
-                    message: `This chat is already linked to ${linkedRepo.repoOwner}/${linkedRepo.repoName}. ` +
-                        'Exporting again is not possible from this chat — push further changes with git, or start a new chat to export to a different repository.',
-                };
-            }
-            const result = {
-                show_widget: true,
-                strategyName: (_a = args.strategyName) !== null && _a !== void 0 ? _a : 'Strategy',
-            };
-            if (typeof args.repoName === 'string' && args.repoName.trim())
-                result.name = args.repoName.trim();
-            if (typeof args.description === 'string' && args.description.trim())
-                result.description = args.description.trim();
-            const rootDir = normalizeExportRootDir(args.rootDir);
-            if (rootDir)
-                result.rootDir = rootDir;
-            return result;
-        });
+        }, (args) => this.exportWorkspace(args));
         this.register('strategies', {
-            name: 'strategies_export',
-            description: 'Export code to a new repository on the default git host. Pass a files array of explicit repo-relative file paths and contents. The new repo will be automatically linked to the current chat session (injecting git credentials and restarting the worker). After export, the user can interact with the repo via git commands.',
+            name: 'strategies_link_workspace',
+            description: 'Link an EXISTING strategy repository (a strategy_link_id from strategies_list) to this chat and attach the workspace to it with git, ' +
+                'immediately, inside this tool call. Use it when the user wants to continue work on a strategy they already exported. ' +
+                'An empty workspace is checked out from the repository default branch. A workspace that already has files is NOT overwritten: ' +
+                'the tool initialises git, fetches the repository, and leaves the files as uncommitted changes on a new branch named in the result — ' +
+                'inspect git status / git diff origin/<default branch>, reconcile, then commit and push. If the workspace is already a git ' +
+                'repository, only the origin remote is repointed. Statuses: "linked", "already_linked" (with the linked repo), "failed". ' +
+                'The chat can be linked to exactly one repository; to export a brand new one use strategies_export_workspace instead.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    files: {
-                        type: 'array',
-                        description: 'Array of files to export with explicit repo-relative paths.',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                path: { type: 'string', description: 'Relative file path in the repo (e.g. "src/strategy.ts").' },
-                                content: { type: 'string', description: 'File content.' },
-                                encoding: { type: 'string', enum: ['utf-8', 'base64'], description: 'Content encoding. Default: "utf-8".' },
-                            },
-                            required: ['path', 'content'],
-                        },
-                    },
-                    repoName: { type: 'string', description: 'Repository name (required).' },
-                    description: { type: 'string', description: 'Repository description.' },
-                    isPrivate: { type: 'boolean', description: 'Whether the new repo should be private. Default: true.' },
+                    strategy_link_id: { type: 'string', description: 'The strategy link ID (from strategies_list).' },
                 },
-                required: ['repoName', 'files'],
+                required: ['strategy_link_id'],
             },
-        }, async (args) => {
-            var _a;
-            const files = args.files;
-            if (!files || files.length === 0) {
-                return { statusCode: 400, error: 'files array is required' };
-            }
-            if (!((_a = args.repoName) === null || _a === void 0 ? void 0 : _a.trim())) {
-                return { statusCode: 400, error: 'repoName is required' };
-            }
-            return this.client.exportToGitHub({
-                files,
-                repoName: args.repoName,
-                description: args.description,
-                isPrivate: args.isPrivate,
-            });
-        });
+        }, (args) => this.linkWorkspace(args));
         this.register('strategies', {
             name: 'backtests_run',
-            description: 'Run a backtest of a linked strategy against historical market data. Use this after the strategy is ' +
-                'exported/pushed to its repository and before deploying — backtests run against a pushed commit, never local files, so ' +
-                'push first and re-run after every code change you want tested. The call submits the run, renders a live backtest ' +
+            description: 'Run a backtest of a linked strategy against historical market data. Use this after the strategy is in its ' +
+                'repository (strategies_export_workspace, or git push on a linked chat) and before deploying — backtests run against a ' +
+                'pushed commit, never local files, so export/push first and re-run after every code change you want tested. ' +
+                'The call submits the run, renders a live backtest ' +
                 'widget in the chat, and PAUSES until the run finishes (typically 1-5 minutes); it then resumes you with the ' +
                 'result summary (total return, Sharpe, max drawdown, win rate, trades, and the run_validity verdict) merged into ' +
                 'this tool result as _widgetResponse — or the failure reason if the run failed. A run whose verdict is INVALID or ' +
@@ -966,7 +1231,7 @@ class PlatformToolHandler {
                 properties: {
                     strategy_link_id: {
                         type: 'string',
-                        description: 'The strategy link ID (from strategies_list or the export confirmation).',
+                        description: 'The strategy link ID (from strategies_list or the strategies_export_workspace result).',
                     },
                     start_time: {
                         type: 'string',
@@ -1345,7 +1610,7 @@ class PlatformToolHandler {
         if (!strategyLinkId) {
             return {
                 statusCode: 400,
-                error: 'strategy_link_id is required — pass the linked strategy id (from strategies_list or the export result).',
+                error: 'strategy_link_id is required — pass the linked strategy id (from strategies_list or the strategies_export_workspace result).',
                 backtest_config: { start_time: startTime, end_time: String((_c = args.end_time) !== null && _c !== void 0 ? _c : '').trim(), include_gas_costs: args.include_gas_costs !== false },
             };
         }