@sireai/optimus 0.1.44 → 0.1.46

package/dist/cli/optimus.js

@@ -29,13 +29,16 @@ import { TaskDeliveryService } from "../task-environment/delivery/task-delivery-
 import { formatDeliveryWarningsWithDescriptions } from "../task-environment/delivery/delivery-warning-copy.js";
 import { FeishuAnalysisDocService } from "../task-environment/delivery/feishu-analysis-doc-service.js";
 import { TaskPublicationService } from "../task-environment/delivery/task-publication-service.js";
-import { FeishuClient } from "../integrations/feishu/feishu-client.js";
+import { FeishuClient, FeishuIntegrationError } from "../integrations/feishu/feishu-client.js";
 import { FeishuDocumentReader, mergeFeishuReferenceMaterials } from "../integrations/feishu/feishu-document-reader.js";
+import { FeishuReferenceMaterialDownloader, isFeishuManagedReferenceMaterial } from "../integrations/feishu/feishu-reference-material-downloader.js";
+import { FeishuUserAuthService } from "../integrations/feishu/feishu-user-auth-service.js";
 import { FeishuUserService } from "../integrations/feishu/feishu-user-service.js";
 import { createFeedbackReport } from "./feedback.js";
 import { DEFAULT_FEEDBACK_RECIPIENT_EMAIL, FeishuFeedbackDeliveryService, persistFeedbackDeliveryResult, resolveDefaultFeedbackRecipientFallbackOpenId } from "./feedback-delivery.js";
 import { resolveDefaultConfigPath, resolveDefaultEnvPath } from "../config/optimus-paths.js";
 import { checkForSelfUpdate, installSelfUpdate, recordSkippedSelfUpdate } from "./self-update.js";
+import { buildDocumentStructure } from "../task-environment/document-input/document-structure.js";
 const CLI_ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const PACKAGE_JSON_PATH = join(CLI_ROOT_DIR, "package.json");
 const execFileAsync = promisify(execFile);
@@ -43,6 +46,35 @@ const PACKAGE_NAME = "@sireai/optimus";
 const JIRA_CLI_ENTRY = join(CLI_ROOT_DIR, "dist", "integrations", "jira", "jira-cli.js");
 const SENTRY_CLI_ENTRY = join(CLI_ROOT_DIR, "dist", "integrations", "sentry", "sentry-cli.js");
 const RELEASE_NOTES_URL = "https://github.com/SireAI/optimus/releases/latest";
+function createSilentSubmitConsoleSink() {
+    return () => {
+        // Submit preprocessing logs are still written to runtime logs; the interactive CLI keeps only loading + final result.
+    };
+}
+function resolveSubmitTaskType(input) {
+    const explicitTaskType = input.explicitTaskType?.trim();
+    if (explicitTaskType) {
+        return explicitTaskType;
+    }
+    if (looksLikePrototypeInput(input)) {
+        return "coder";
+    }
+    return "bugfix";
+}
+function looksLikePrototypeInput(input) {
+    const normalizedFileName = basename(input.filePath?.trim() ?? "").toLowerCase();
+    if (normalizedFileName === "prototype.html" || normalizedFileName === "prototype.htm") {
+        return true;
+    }
+    return (input.referenceMaterials ?? []).some((material) => isPrototypeReferenceMaterial(material));
+}
+function isPrototypeReferenceMaterial(material) {
+    if (material.type !== "file") {
+        return false;
+    }
+    const normalizedTitle = material.title.trim().toLowerCase();
+    return normalizedTitle === "prototype.html" || normalizedTitle === "prototype.htm";
+}
 const DOCTOR_ANSI = {
     reset: "\u001B[0m",
     green: "\u001B[32m",
@@ -181,6 +213,61 @@ async function runWithTerminalLoading(message, action) {
         throw error;
     }
 }
+async function runFeishuUserAuth(subcommand, commandArgs) {
+    const action = (subcommand?.trim() || "auth").toLowerCase();
+    const args = parseArgs(commandArgs);
+    const config = await loadConfig().catch(() => buildDefaultConfig());
+    const authService = new FeishuUserAuthService({ config });
+    if (action === "status") {
+        const user = await authService.readAuthorizedUser();
+        if (!user) {
+            console.log("Feishu user auth: not authorized");
+            console.log("Run `optimus feishu auth` to authorize your user account.");
+            return 1;
+        }
+        console.log("Feishu user auth: authorized");
+        if (user.openId) {
+            console.log(`Open ID: ${user.openId}`);
+        }
+        if (user.userId) {
+            console.log(`User ID: ${user.userId}`);
+        }
+        if (user.source) {
+            console.log(`Source: ${user.source}`);
+        }
+        console.log(`Expires: ${new Date(user.expireAtMs).toISOString()}`);
+        return 0;
+    }
+    if (action === "logout") {
+        await authService.clearAuthorizedUser();
+        console.log("Feishu user authorization cleared.");
+        return 0;
+    }
+    if (action !== "auth") {
+        console.error(renderCommandHelp("feishu") ?? "Unknown `optimus feishu` subcommand.");
+        return 1;
+    }
+    let announcedUrl = "";
+    const result = await authService.loginDeviceCode({
+        openBrowser: args["no-open"] !== "true",
+        onVerificationUri: (url, expiresIn) => {
+            announcedUrl = url;
+            console.log(`Open this URL to authorize Feishu access (expires in ${expiresIn}s):`);
+            console.log(url);
+            console.log("");
+            console.log("Waiting for authorization...");
+        }
+    });
+    if (!announcedUrl) {
+        console.log("Waiting for authorization...");
+    }
+    console.log("Feishu user authorization succeeded.");
+    console.log(`Authorization URL: ${result.verificationUriComplete}`);
+    if (result.openId) {
+        console.log(`Open ID: ${result.openId}`);
+    }
+    return 0;
+}
 function renderDoctorSection(title, section, extraLines = []) {
     const lines = [formatDoctorStatusHeading(title, section.status)];
     if (section.reason) {
@@ -261,6 +348,7 @@ function renderCliHelp() {
         "",
         "Common commands:",
         "  submit               Submit a problem for Optimus to handle",
+        "  feishu auth          Authorize your Feishu user account for protected docs/wiki",
         "  jira-submit-issue    Submit a Jira issue into Optimus",
         "  sentry-submit-event  Submit a Sentry event into Optimus",
         "  repo list            Show registered repositories",
@@ -294,6 +382,7 @@ function renderAdvancedCliHelp() {
         "  version              Show the installed package version",
         "",
         "Advanced commands:",
+        "  feishu auth|status|logout",
         "  delivery-status       Show focused delivery/publication state",
         "  notify-test           Send or preview a Feishu test notification",
         "  delivery-retry        Replay notification delivery from persisted bundle data",
@@ -462,6 +551,22 @@ function renderCommandHelp(command) {
             "Optional:",
             "  --json                       Print JSON output for automation"
         ].join("\n"),
+        feishu: [
+            "optimus feishu",
+            "",
+            "Usage:",
+            "  optimus feishu auth [options]",
+            "  optimus feishu status",
+            "  optimus feishu logout",
+            "",
+            "Subcommands:",
+            "  auth                 Start Feishu user authorization via device code flow",
+            "  status               Show whether a Feishu user token is stored",
+            "  logout               Clear the stored Feishu user token",
+            "",
+            "Options for `auth`:",
+            "  --no-open            Print the authorization URL without opening a browser"
+        ].join("\n"),
         advanced: renderAdvancedCliHelp(),
         "notify-test": [
             "optimus notify-test",
@@ -2346,9 +2451,14 @@ function isFeishuDocumentUrl(value) {
         || /^https?:\/\/(?:[\w-]+\.)?larksuite\.com\//iu.test(value.trim());
 }
 function extractTitleFromMarkdown(markdown) {
-    const match = markdown.match(/<title>([\s\S]*?)<\/title>/iu);
-    const title = match?.[1]?.trim();
-    return title ? title : undefined;
+    const htmlTitleMatch = markdown.match(/<title>([\s\S]*?)<\/title>/iu);
+    const htmlTitle = htmlTitleMatch?.[1]?.trim();
+    if (htmlTitle) {
+        return htmlTitle;
+    }
+    const markdownHeadingMatch = markdown.match(/^\s*#\s+(.+?)\s*$/mu);
+    const markdownHeading = markdownHeadingMatch?.[1]?.trim();
+    return markdownHeading ? markdownHeading : undefined;
 }
 function parseHtmlAttributeMap(fragment) {
     const attributes = {};
@@ -2397,6 +2507,7 @@ function extractFeishuReferenceMaterials(markdown, media, sourceUrl) {
             const record = entry;
             const token = typeof record.token === "string" ? record.token.trim() : "";
             const type = typeof record.type === "string" ? record.type.trim() : "";
+            const name = typeof record.name === "string" ? record.name.trim() : "";
             if (!token || !type) {
                 continue;
             }
@@ -2413,7 +2524,7 @@ function extractFeishuReferenceMaterials(markdown, media, sourceUrl) {
             embeddedFileCount += 1;
             pushReference({
                 type: "file",
-                title: `Embedded ${type} ${embeddedFileCount}`,
+                title: name || `Embedded ${type} ${embeddedFileCount}`,
                 token,
                 sourceType: "feishu_media"
             });
@@ -2440,9 +2551,11 @@ function extractFeishuReferenceMaterials(markdown, media, sourceUrl) {
     while ((htmlImageMatch = htmlImagePattern.exec(markdown)) !== null) {
         embeddedImageCount += 1;
         const attrs = parseHtmlAttributeMap(htmlImageMatch[1] ?? "");
+        const title = selectFeishuImageTitle(attrs, embeddedImageCount);
         pushReference({
             type: "image",
-            title: attrs.name?.trim() || `Embedded image ${embeddedImageCount}`,
+            title,
+            ...(attrs.href?.trim() ? { url: attrs.href.trim() } : {}),
             ...(attrs.src?.trim() ? { token: attrs.src.trim() } : {}),
             ...(attrs.mime?.trim() ? { mimeType: attrs.mime.trim() } : {}),
             sourceType: "feishu_markdown"
@@ -2541,7 +2654,18 @@ function extractFeishuReferenceMaterials(markdown, media, sourceUrl) {
     }
     return references.length > 0 ? references : undefined;
 }
-async function resolveTaskTextFromUrl(url) {
+function selectFeishuImageTitle(attributes, ordinal) {
+    const alt = attributes.alt?.trim();
+    if (alt) {
+        return alt;
+    }
+    const name = attributes.name?.trim();
+    if (name) {
+        return name;
+    }
+    return `Embedded image ${ordinal}`;
+}
+async function resolveTaskTextFromUrl(url, config, logger) {
     const trimmedUrl = url.trim();
     if (!trimmedUrl) {
         throw new Error("Task document URL is empty.");
@@ -2549,60 +2673,228 @@ async function resolveTaskTextFromUrl(url) {
     if (!isFeishuDocumentUrl(trimmedUrl)) {
         throw new Error("submit currently supports document URLs from Feishu/Lark only.");
     }
-    const reader = new FeishuDocumentReader();
     try {
-        const resolved = await reader.readFromUrl(trimmedUrl);
-        const referenceMaterials = mergeFeishuReferenceMaterials(extractFeishuReferenceMaterials(resolved.content, undefined, trimmedUrl), resolved.referenceMaterials);
-        return {
-            content: resolved.content,
-            ...(resolved.title ? { title: resolved.title } : {}),
-            sourceType: resolved.sourceType,
-            ...(resolved.sourceDocumentType ? { sourceDocumentType: resolved.sourceDocumentType } : {}),
-            ...(referenceMaterials ? { referenceMaterials } : {})
-        };
+        return await resolveTaskTextFromUrlWithAuthMode(trimmedUrl, "tenant", config, logger);
     }
     catch (builtinError) {
-        let stdout;
-        try {
-            const result = await execFileAsync("feishu", ["fetch", trimmedUrl], {
-                maxBuffer: 10 * 1024 * 1024
-            });
-            stdout = result.stdout;
+        if (shouldRetryFeishuSubmitWithUserAuth(builtinError) && config) {
+            const userAuthService = new FeishuUserAuthService({ config });
+            const hadStoredUserAuth = await userAuthService.hasAuthorizedUser();
+            if (hadStoredUserAuth) {
+                try {
+                    return await resolveTaskTextFromUrlWithAuthMode(trimmedUrl, "user", config, logger);
+                }
+                catch (userError) {
+                    if (shouldRetryFeishuSubmitWithFreshUserAuth(userError)) {
+                        try {
+                            const adopted = await userAuthService.adoptLegacyCliSession();
+                            if (adopted) {
+                                return await resolveTaskTextFromUrlWithAuthMode(trimmedUrl, "user", config, logger);
+                            }
+                        }
+                        catch {
+                            // Ignore legacy session adoption failures and continue to interactive re-authorization.
+                        }
+                        try {
+                            await startFeishuUserAuthForSubmit(userAuthService);
+                            return await resolveTaskTextFromUrlWithAuthMode(trimmedUrl, "user", config, logger);
+                        }
+                        catch (reauthError) {
+                            const appDetail = formatFeishuSubmitError(builtinError);
+                            const userDetail = formatFeishuSubmitError(userError);
+                            const reauthDetail = reauthError instanceof Error ? reauthError.message : String(reauthError);
+                            throw new Error(`submit could not fetch the Feishu document via the built-in Feishu app (${appDetail}). `
+                                + `Stored user authorization was insufficient (${userDetail}). `
+                                + `Automatic user re-authorization also failed (${reauthDetail}).`);
+                        }
+                    }
+                    const appDetail = formatFeishuSubmitError(builtinError);
+                    const userDetail = formatFeishuSubmitError(userError);
+                    throw new Error(`submit could not fetch the Feishu document via the built-in Feishu app (${appDetail}). User-auth fallback also failed (${userDetail}).`);
+                }
+            }
+            const builtinDetail = formatFeishuSubmitError(builtinError);
+            try {
+                await startFeishuUserAuthForSubmit(userAuthService);
+                try {
+                    return await resolveTaskTextFromUrlWithAuthMode(trimmedUrl, "user", config, logger);
+                }
+                catch (freshUserError) {
+                    if (shouldRetryFeishuSubmitWithFreshUserAuth(freshUserError)) {
+                        const scopeDetail = formatFeishuSubmitError(freshUserError);
+                        throw new Error(`Feishu user authorization succeeded, but the authorized Optimus Feishu app still lacks the required user privileges (${scopeDetail}). `
+                            + "Open the app's user scopes, publish the updated Feishu app version, then authorize again with `optimus feishu auth`.");
+                    }
+                    throw freshUserError;
+                }
+            }
+            catch (authError) {
+                const authDetail = authError instanceof Error ? authError.message : String(authError);
+                throw new Error(`submit could not fetch the Feishu document via the built-in Feishu app (${builtinDetail}). `
+                    + `Automatic Feishu user authorization failed (${authDetail}).`);
+            }
         }
-        catch (error) {
-            const execError = error;
-            const cliDetail = execError?.code === "ENOENT"
-                ? "the `feishu` CLI is not installed or not on PATH"
-                : execError?.stderr?.trim() || execError?.stdout?.trim() || execError?.message || "unknown error";
-            const builtinDetail = builtinError instanceof Error ? builtinError.message : String(builtinError);
-            throw new Error(`submit could not fetch the Feishu document via built-in app (${builtinDetail}) or via \`feishu fetch\` (${cliDetail}).`);
-        }
-        let payload;
-        try {
-            payload = JSON.parse(stdout);
+        const builtinDetail = formatFeishuSubmitError(builtinError);
+        throw new Error(`submit could not fetch the Feishu document via the built-in Feishu app (${builtinDetail}).`);
+    }
+}
+async function startFeishuUserAuthForSubmit(authService) {
+    let announcedUrl = "";
+    console.error("Feishu document access requires user authorization. Starting authorization flow...");
+    await authService.loginDeviceCode({
+        onVerificationUri: (url, expiresIn) => {
+            announcedUrl = url;
+            console.error(`Authorize Feishu access in your browser within ${expiresIn}s:`);
+            console.error(url);
+            console.error("Waiting for authorization...");
         }
-        catch {
-            throw new Error("submit received non-JSON output from `feishu fetch`.");
+    });
+    if (!announcedUrl) {
+        console.error("Waiting for authorization...");
+    }
+    console.error("Feishu user authorization completed. Retrying document fetch...");
+}
+async function resolveTaskTextFromUrlWithAuthMode(trimmedUrl, authMode, config, logger) {
+    const reader = new FeishuDocumentReader({
+        ...(config ? { config } : {}),
+        client: new FeishuClient({
+            ...(config ? { config } : {}),
+            authMode
+        })
+    });
+    const resolved = await reader.readFromUrl(trimmedUrl);
+    const resolvedTitle = resolved.title?.trim() || extractTitleFromMarkdown(resolved.content);
+    const referenceMaterials = mergeFeishuReferenceMaterials(extractFeishuReferenceMaterials(resolved.content, undefined, trimmedUrl), resolved.referenceMaterials);
+    await logger?.info("reference_materials.detected", {
+        sourceUrl: trimmedUrl,
+        sourceDocumentType: resolved.sourceDocumentType ?? null,
+        materialCount: referenceMaterials?.length ?? 0,
+        fileCount: referenceMaterials?.filter((entry) => entry.type === "file").length ?? 0,
+        imageCount: referenceMaterials?.filter((entry) => entry.type === "image").length ?? 0,
+        structuredObjectCount: referenceMaterials?.filter((entry) => !["file", "image", "link"].includes(entry.type)).length ?? 0,
+        feishuAuthMode: authMode
+    });
+    const downloadedReferenceMaterials = config
+        ? await new FeishuReferenceMaterialDownloader({
+            config,
+            client: new FeishuClient({
+                config,
+                authMode
+            }),
+            ...(logger ? { logger } : {})
+        }).downloadReferenceMaterials(referenceMaterials ?? [], buildRemoteInputNamespace(trimmedUrl), trimmedUrl)
+        : referenceMaterials;
+    await ensureFeishuImageDownloadsSucceeded(downloadedReferenceMaterials, trimmedUrl, logger);
+    const documentStructure = buildDocumentStructure(resolved.content, {
+        ...(resolvedTitle ? { title: resolvedTitle } : {}),
+        sourceUrl: trimmedUrl,
+        ...(downloadedReferenceMaterials ? { referenceMaterials: downloadedReferenceMaterials } : {})
+    });
+    return {
+        content: resolved.content,
+        ...(resolvedTitle ? { title: resolvedTitle } : {}),
+        sourceType: resolved.sourceType,
+        ...(resolved.sourceDocumentType ? { sourceDocumentType: resolved.sourceDocumentType } : {}),
+        ...(documentStructure.referenceMaterials && documentStructure.referenceMaterials.length > 0 ? { referenceMaterials: documentStructure.referenceMaterials } : {}),
+        documentMap: documentStructure.documentMap,
+        ...(documentStructure.evidenceBundles.length > 0 ? { evidenceBundles: documentStructure.evidenceBundles } : {})
+    };
+}
+function formatFeishuSubmitError(error) {
+    if (error instanceof FeishuIntegrationError) {
+        const parts = [error.message];
+        const status = Number.isFinite(error.diagnostics.status) ? String(error.diagnostics.status) : undefined;
+        const code = Number.isFinite(error.diagnostics.code) ? String(error.diagnostics.code) : undefined;
+        if (status) {
+            parts.push(`status=${status}`);
+        }
+        if (code) {
+            parts.push(`code=${code}`);
+        }
+        const detail = extractFeishuErrorDetail(error.diagnostics.detail);
+        if (detail) {
+            parts.push(detail);
         }
-        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-            throw new Error("submit received an invalid response from `feishu fetch`.");
+        return parts.join(", ");
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+function extractFeishuErrorDetail(detail) {
+    const trimmed = detail?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const candidates = [
+            typeof parsed.msg === "string" ? parsed.msg.trim() : "",
+            typeof parsed.error?.message === "string" ? parsed.error.message.trim() : ""
+        ].filter((entry) => entry.length > 0);
+        if (candidates.length > 0) {
+            return candidates.join(" | ");
         }
-        const record = payload;
-        const markdown = typeof record.markdown === "string" ? record.markdown.trim() : "";
-        const title = (typeof record.title === "string" ? record.title.trim() : "") || extractTitleFromMarkdown(markdown);
-        const sourceDocumentType = typeof record.type === "string" ? record.type.trim() : undefined;
-        const referenceMaterials = extractFeishuReferenceMaterials(markdown, record.media, trimmedUrl);
-        if (!markdown) {
-            throw new Error("submit fetched the document URL, but it did not return readable markdown content.");
+    }
+    catch {
+        return trimmed;
+    }
+    return trimmed;
+}
+function shouldRetryFeishuSubmitWithUserAuth(error) {
+    if (!(error instanceof FeishuIntegrationError)) {
+        return false;
+    }
+    if (error.diagnostics.code === 131006) {
+        return true;
+    }
+    const detail = error.diagnostics.detail?.toLowerCase() ?? "";
+    return /permission denied|tenant needs read permission|node permission denied/.test(detail);
+}
+function shouldRetryFeishuSubmitWithFreshUserAuth(error) {
+    if (error instanceof FeishuIntegrationError) {
+        if (error.diagnostics.code === 99991679) {
+            return true;
         }
-        return {
-            content: markdown,
-            ...(title ? { title } : {}),
-            sourceType: "feishu_doc",
-            ...(sourceDocumentType ? { sourceDocumentType } : {}),
-            ...(referenceMaterials ? { referenceMaterials } : {})
-        };
+        const detail = error.diagnostics.detail?.toLowerCase() ?? "";
+        return /request user re-authorization|user re-authorization|docs:document\.media:download|unauthorized/.test(detail);
+    }
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return /99991679|request user re-authorization|user re-authorization|docs:document\.media:download/.test(message);
+}
+function buildRemoteInputNamespace(sourceUrl) {
+    const compactTime = new Date().toISOString().replace(/[-:TZ.]/gu, "").slice(0, 14);
+    const token = sourceUrl.match(/\/(?:docx|wiki)\/([A-Za-z0-9]+)/u)?.[1]?.trim() || "remote-doc";
+    return `${compactTime}-${token}`;
+}
+async function ensureFeishuImageDownloadsSucceeded(materials, sourceUrl, logger) {
+    const images = (materials ?? []).filter((entry) => entry.type === "image" && isFeishuManagedReferenceMaterial(entry));
+    if (images.length === 0) {
+        return;
     }
+    const missing = images.filter((entry) => !entry.localPath?.trim() || entry.downloadStatus !== "downloaded");
+    if (missing.length === 0) {
+        return;
+    }
+    const detail = missing
+        .slice(0, 3)
+        .map((entry) => {
+        const title = entry.title?.trim() || "Untitled image";
+        const reason = entry.downloadError?.trim()
+            || (entry.downloadStatus === "skipped" ? "download was skipped" : "no local file was produced");
+        return `${title} (${reason})`;
+    })
+        .join("; ");
+    const remainder = missing.length > 3 ? `; and ${missing.length - 3} more` : "";
+    await logger?.warn("reference_materials.image_download_blocked", {
+        sourceUrl,
+        imageCount: images.length,
+        missingImageCount: missing.length,
+        missingImageTitles: missing.map((entry) => entry.title),
+        missingImageReasons: missing.map((entry) => entry.downloadError ?? entry.downloadStatus ?? "missing_local_path")
+    });
+    throw new Error(`submit could not prepare ${missing.length}/${images.length} embedded image(s) from the Feishu document. `
+        + `Embedded screenshots must be downloaded before the task starts. `
+        + `Failed image(s): ${detail}${remainder}. `
+        + "Check Feishu document image permissions and retry.");
 }
 async function main() {
     const argv = process.argv.slice(2);
@@ -2707,8 +2999,7 @@ async function main() {
         return;
     }
     if (command === "feishu") {
-        console.log("Feishu user-session commands have been removed. Optimus now uses the built-in Feishu app for delivery and document publishing.");
-        process.exitCode = 1;
+        process.exitCode = await runFeishuUserAuth(commandArgs[0], commandArgs.slice(1));
         return;
     }
     if (mapJiraCommand(command)) {
@@ -2795,7 +3086,6 @@ async function main() {
     if (command === "submit") {
         const args = parseArgs(commandArgs);
         const explicitTitle = args.title?.trim();
-        const taskType = args["task-type"]?.trim() || "bugfix";
         const inlineDescription = args.desc?.trim() || args.description?.trim();
         const filePath = args.file?.trim();
         const url = args.url?.trim();
@@ -2811,6 +3101,8 @@ async function main() {
         let remoteDocumentTitle;
         let remoteDocumentType;
         let referenceMaterials;
+        let documentMap;
+        let evidenceBundles;
         if (inlineDescription) {
             description = inlineDescription;
         }
@@ -2819,13 +3111,15 @@ async function main() {
         }
         else {
             try {
-                const remote = await runWithTerminalLoading("Resolving remote requirement document", async () => await resolveTaskTextFromUrl(url));
+                const remote = await OptimusLogger.withConsoleSink(createSilentSubmitConsoleSink(), async () => await runWithTerminalLoading("Resolving remote requirement document", async () => await resolveTaskTextFromUrl(url, config, logger)));
                 description = remote.content;
                 resolvedTitle = resolvedTitle || remote.title;
                 remoteSourceType = remote.sourceType;
                 remoteDocumentTitle = remote.title;
                 remoteDocumentType = remote.sourceDocumentType;
                 referenceMaterials = remote.referenceMaterials;
+                documentMap = remote.documentMap;
+                evidenceBundles = remote.evidenceBundles;
             }
             catch (error) {
                 console.error(error instanceof Error ? error.message : String(error));
@@ -2833,36 +3127,49 @@ async function main() {
                 return;
             }
         }
-        if (!resolvedTitle || !description) {
-            console.error(renderShellQuotingHint("submit"));
+        const taskType = resolveSubmitTaskType({
+            ...(args["task-type"]?.trim() ? { explicitTaskType: args["task-type"].trim() } : {}),
+            ...(filePath ? { filePath } : {}),
+            ...(referenceMaterials ? { referenceMaterials } : {})
+        });
+        if (!description) {
+            console.error(url
+                ? "submit resolved the remote document, but it did not produce readable content."
+                : renderShellQuotingHint("submit"));
             process.exitCode = 1;
             return;
         }
-        if (!description) {
-            console.error(renderShellQuotingHint("submit"));
+        if (!resolvedTitle) {
+            console.error(url
+                ? "submit resolved the remote document content, but could not determine a title. Pass --title explicitly."
+                : renderShellQuotingHint("submit"));
             process.exitCode = 1;
             return;
         }
-        await store.init();
-        const repositorySelection = await resolveSubmissionRepositorySelector(taskType, args, store, config);
+        await runWithTerminalLoading("Checking submission workspace", async () => await store.init());
+        const repositorySelection = await runWithTerminalLoading("Resolving submission target", async () => await resolveSubmissionRepositorySelector(taskType, args, store, config));
         if (!repositorySelection.ok) {
             console.error(repositorySelection.reason);
             process.exitCode = 1;
             return;
         }
+        const shouldPersistTaskTypeHint = Boolean(args["task-type"]?.trim()) || taskType !== "bugfix";
         const event = createManualProblemEvent({
             ...args,
             title: resolvedTitle,
             description,
+            ...(shouldPersistTaskTypeHint ? { "task-type": taskType } : {}),
             ...(url ? { sourceUrl: url } : {}),
             ...(remoteSourceType ? { "source-type": remoteSourceType } : {}),
             ...(remoteDocumentTitle ? { "source-document-title": remoteDocumentTitle } : {}),
             ...(remoteDocumentType ? { "source-document-type": remoteDocumentType } : {}),
             ...(referenceMaterials ? { "reference-materials-json": JSON.stringify(referenceMaterials) } : {}),
+            ...(documentMap ? { "document-map-json": JSON.stringify(documentMap) } : {}),
+            ...(evidenceBundles ? { "evidence-bundles-json": JSON.stringify(evidenceBundles) } : {}),
             ...(repositorySelection.repoSelector ? { repo: repositorySelection.repoSelector } : {}),
             ...(args["allow-duplicate"] === "true" ? { "allow-duplicate": "true" } : {})
         });
-        await runtime.writeManualSubmission(event);
+        await runWithTerminalLoading("Submitting task", async () => await runtime.writeManualSubmission(event));
         console.log("[optimus] submit succeeded");
         return;
     }