@sireai/optimus 0.1.40 → 0.1.42

package/dist/cli/optimus.js

@@ -17,6 +17,7 @@ import { classifyCodexFailureCategory } from "../problem-solving-core/codex/code
 import { createManualEventContent, createManualProblemEvent } from "../task-environment/intake/manual-problem-intake.js";
 import { OptimusLogger } from "../task-environment/observability/logger.js";
 import { TaskOrchestrator } from "../task-environment/orchestration/task-orchestrator.js";
+import { getTaskRuntimePolicy } from "../task-environment/orchestration/task-runtime-policy.js";
 import { TriageRunner } from "../task-environment/orchestration/triage-runner.js";
 import { OptimusRuntime } from "../task-environment/runtime/optimus-runtime.js";
 import { SQLiteTaskStore } from "../task-environment/storage/sqlite-task-store.js";
@@ -63,6 +64,9 @@ function renderSetupResult(result) {
         lines.push("Repository: not configured");
     }
     lines.push(`Delivery: ${result.deliveryChannels.join(", ")}`);
+    if (result.feishuDefaultRecipientEmail) {
+        lines.push(`Feishu Recipient: ${result.feishuDefaultRecipientEmail}`);
+    }
     lines.push(`Jira: ${result.jiraEnabled ? "enabled" : "disabled"}`);
     lines.push(`Sentry: ${result.sentryEnabled ? "enabled" : "disabled"}`);
     const providerLabel = result.codexAuth.provider ? ` | Provider: ${result.codexAuth.provider.displayName} (${result.codexAuth.provider.id})` : "";
@@ -316,23 +320,26 @@ function renderCommandHelp(command) {
             "",
             "Usage:",
             "  optimus submit --title <title> --description <text> [options]",
-            "  optimus submit --title <title> --description-file <path> [options]",
-            "  printf '%s' '<text>' | optimus submit --title <title> --description-stdin [options]",
+            "  optimus submit --title <title> --file <path> [options]",
+            "  optimus submit --url <url> [--title <title>] [options]",
             "",
             "Required:",
-            "  --title <title>              Task title",
-            "  --description <text>         Task description",
+            "  exactly one of:",
+            "    --description <text>       Task text",
+            "    --file <path>              Read task text from a file",
+            "    --url <url>                Read task text from a remote document URL",
+            "  --title <title>              Task title; optional only when --url resolves a document title",
             "",
             "Common options:",
-            "  --description-file <path>    Read task description from a file",
-            "  --description-stdin          Read task description from stdin",
             "  --repo <alias>               Target registered repository alias",
             "  --task-type <type>           Task type, default bugfix",
             "  --source-ref <id>            External issue key or source reference",
             "  --allow-duplicate            Allow duplicate submission",
             "",
             "Example:",
-            "  optimus submit --title \"Login crash\" --description \"Crash on startup\" --repo ohos-pre"
+            "  optimus submit --title \"Login crash\" --description \"Crash on startup\" --repo ohos-pre",
+            "  optimus submit --title \"Onboarding prototype\" --file ./docs/onboarding-prd.md --task-type pm",
+            "  optimus submit --url https://mi.feishu.cn/docx/ABC123 --task-type pm"
         ].join("\n"),
         feedback: [
             "optimus feedback",
@@ -830,6 +837,7 @@ async function promptForStartupSelfUpdate(currentVersion, latestVersion) {
     }
 }
 async function maybeHandleStartupSelfUpdate(input) {
+    const suppressSubmitOutput = input.command === "submit";
     const check = await checkForSelfUpdate({
         command: input.command,
         config: input.config,
@@ -846,47 +854,54 @@ async function maybeHandleStartupSelfUpdate(input) {
             const nextCheckAt = Number.isFinite(lastCheckedAtMs)
                 ? new Date(lastCheckedAtMs + intervalHours * 60 * 60 * 1000).toISOString()
                 : null;
-            await input.logger.info("self_update.cached", {
+            if (!suppressSubmitOutput) {
+                await input.logger.info("self_update.cached", {
+                    command: input.command,
+                    currentVersion: check.currentVersion,
+                    latestVersion: check.latestVersion ?? null,
+                    channel: check.channel,
+                    installSource: check.installSource,
+                    intervalHours,
+                    lastCheckedAt,
+                    nextCheckAt,
+                    realtimeCheckSkipped: true
+                });
+            }
+        }
+        return { handled: false };
+    }
+    if (check.reason === "check_failed") {
+        if (!suppressSubmitOutput) {
+            await input.logger.warn("self_update.check_failed", {
                 command: input.command,
-                currentVersion: check.currentVersion,
-                latestVersion: check.latestVersion ?? null,
-                channel: check.channel,
-                installSource: check.installSource,
-                intervalHours,
-                lastCheckedAt,
-                nextCheckAt,
-                realtimeCheckSkipped: true
+                reason: check.state.lastError ?? "unknown"
             });
         }
         return { handled: false };
     }
-    if (check.reason === "check_failed") {
-        await input.logger.warn("self_update.check_failed", {
+    if (!suppressSubmitOutput) {
+        await input.logger.info(check.updateAvailable ? "self_update.available" : "self_update.current", {
             command: input.command,
-            reason: check.state.lastError ?? "unknown"
+            currentVersion: check.currentVersion,
+            latestVersion: check.latestVersion ?? null,
+            channel: check.channel,
+            installSource: check.installSource
         });
-        return { handled: false };
     }
-    await input.logger.info(check.updateAvailable ? "self_update.available" : "self_update.current", {
-        command: input.command,
-        currentVersion: check.currentVersion,
-        latestVersion: check.latestVersion ?? null,
-        channel: check.channel,
-        installSource: check.installSource
-    });
     if (!check.updateAvailable || !check.latestVersion) {
         return { handled: false };
     }
     if (check.reason === "skipped_version") {
-        await input.logger.info("self_update.skipped_version", {
-            command: input.command,
-            currentVersion: check.currentVersion,
-            latestVersion: check.latestVersion
-        });
+        if (!suppressSubmitOutput) {
+            await input.logger.info("self_update.skipped_version", {
+                command: input.command,
+                currentVersion: check.currentVersion,
+                latestVersion: check.latestVersion
+            });
+        }
         return { handled: false };
     }
     if (input.command !== "start") {
-        console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
         return { handled: false };
     }
     if (selfUpdateConfig.mode === "prompt") {
@@ -1197,6 +1212,8 @@ async function promptSetupAnswers(defaults) {
         printSetupSection("Feishu", "Built-in Feishu app delivery is already available. Add a webhook only if group notifications should go to a chat first. Type \"\" to clear an existing optional value.");
         printSetupHint("Feishu webhook: optional; leave empty to use direct Feishu app delivery only.");
         const feishuWebhook = resolveOptionalTextAnswer(await ask(renderSetupPrompt("Optional", "Feishu webhook", defaults.feishuWebhook ? "configured" : "")), defaults.feishuWebhook ?? undefined);
+        printSetupHint("Feishu default recipient email: optional; used as a fallback for direct Feishu app delivery when no webhook and no task assignee are available.");
+        const feishuRecipientEmail = resolveOptionalTextAnswer(await ask(renderSetupPrompt("Optional", "Feishu default recipient email", defaults.feishuRecipientEmail ?? "")), defaults.feishuRecipientEmail ?? undefined);
         printSetupSection("Jira", "Optional. Turn this on only if you want this machine to read Jira issues or write Jira comments.");
         printSetupHint("If disabled, Optimus still works; Jira commands just stay unavailable on this machine.");
         const enableJiraInput = (await ask(renderSetupPrompt("Optional integration", "Enable Jira integration", defaults.enableJira ? "Y/n" : "y/N"))).trim().toLowerCase();
@@ -1235,6 +1252,7 @@ async function promptSetupAnswers(defaults) {
             ...(codexProviderBaseUrl ? { codexProviderBaseUrl } : {}),
             ...(codexProviderApiKeyEnvName ? { codexProviderApiKeyEnvName } : {}),
             ...(feishuWebhook !== undefined ? { feishuWebhook } : {}),
+            ...(feishuRecipientEmail !== undefined ? { feishuRecipientEmail } : {}),
             enableJira,
             ...(jiraBaseUrl ? { jiraBaseUrl } : {}),
             ...(jiraPersonalToken ? { jiraPersonalToken } : {}),
@@ -1286,6 +1304,7 @@ async function resolveDefaultSetupAnswers() {
         ...(provider?.baseUrl ? { codexProviderBaseUrl: provider.baseUrl } : {}),
         ...(provider?.apiKeyEnvName ? { codexProviderApiKeyEnvName: provider.apiKeyEnvName } : {}),
         ...(config.delivery.feishu.webhook ? { feishuWebhook: config.delivery.feishu.webhook } : {}),
+        ...(config.delivery.feishu.defaultRecipient?.email ? { feishuRecipientEmail: config.delivery.feishu.defaultRecipient.email } : {}),
         enableJira: config.jira.enabled,
         ...(config.jira.baseUrl ? { jiraBaseUrl: config.jira.baseUrl } : {}),
         ...(config.jira.personalToken ? { jiraPersonalToken: config.jira.personalToken } : {}),
@@ -1487,6 +1506,19 @@ function buildSetupConfig(answers, rawConfig) {
         delete config.delivery.feishu.webhook;
         delete config.delivery.feishu.webhooks;
     }
+    if (typeof answers.feishuRecipientEmail === "string") {
+        config.delivery.feishu.defaultRecipient = {
+            email: answers.feishuRecipientEmail
+        };
+    }
+    else if (answers.feishuRecipientEmail === null) {
+        delete config.delivery.feishu.defaultRecipient;
+    }
+    else if (rawConfig?.delivery?.feishu?.defaultRecipient) {
+        config.delivery.feishu.defaultRecipient = {
+            ...rawConfig.delivery.feishu.defaultRecipient
+        };
+    }
     config.jira.enabled = answers.enableJira;
     if (answers.enableJira) {
         config.jira.baseUrl = answers.jiraBaseUrl ?? config.jira.baseUrl;
@@ -2044,6 +2076,7 @@ async function runSetup(args) {
             }
         } : {}),
         deliveryChannels: config.delivery.channels,
+        ...(config.delivery.feishu.defaultRecipient?.email ? { feishuDefaultRecipientEmail: config.delivery.feishu.defaultRecipient.email } : {}),
         jiraEnabled: config.jira.enabled,
         sentryEnabled: config.sentry.enabled,
         codexAuth: {
@@ -2065,6 +2098,7 @@ function inferArtifactDir(artifacts, bundle) {
     const candidates = [
         bundle?.artifacts.resultMd,
         bundle?.artifacts.patchDiff,
+        bundle?.artifacts.prototypeHtml,
         ...artifacts.map((artifact) => artifact.path)
     ].filter((value) => typeof value === "string" && value.trim().length > 0);
     const artifactPath = candidates.find((candidate) => candidate.includes(`${join(".optimus", "artifacts")}${candidate.includes("\\") ? "\\" : "/"}`))
@@ -2110,6 +2144,7 @@ async function buildReplayExecutionContext(input) {
         : undefined;
     return {
         taskRootDir,
+        runtimePolicy: getTaskRuntimePolicy(input.taskType),
         addresses: {
             mode,
             workspaceDir,
@@ -2260,30 +2295,295 @@ async function resolveLongTextArg(args, keys) {
             return value;
         }
     }
-    const filePath = keys.file ? args[keys.file]?.trim() : undefined;
-    if (filePath) {
-        const content = (await readFile(filePath, "utf8")).trim();
-        if (content) {
-            return content;
+    const fileKeys = typeof keys.file === "string" ? [keys.file] : (keys.file ?? []);
+    for (const key of fileKeys) {
+        const filePath = args[key]?.trim();
+        if (filePath) {
+            const content = (await readFile(filePath, "utf8")).trim();
+            if (content) {
+                return content;
+            }
         }
     }
-    if (keys.stdin && args[keys.stdin] === "true") {
-        const content = (await readTextFromStdin()).trim();
-        if (content) {
-            return content;
+    const stdinKeys = typeof keys.stdin === "string" ? [keys.stdin] : (keys.stdin ?? []);
+    for (const key of stdinKeys) {
+        if (args[key] === "true") {
+            const content = (await readTextFromStdin()).trim();
+            if (content) {
+                return content;
+            }
         }
     }
     return undefined;
 }
 function renderShellQuotingHint(command) {
+    const requirementHint = command === "submit"
+        ? "Provide exactly one of --description, --file, or --url. --title is optional only when --url resolves a document title."
+        : "Use single quotes, or pass the text with --description-file / --description-stdin.";
     return [
-        `${command} requires both --title and --description.`,
+        command === "submit"
+            ? "submit requires exactly one of --description, --file, or --url, plus --title unless --url resolves a document title."
+            : "feedback requires both --title and --description.",
         "Tip: shell metacharacters like `...`, $(...), and $VAR may be expanded before Optimus starts.",
-        "Use single quotes, or pass the text with --description-file / --description-stdin.",
+        requirementHint,
         `Example: optimus ${command} --title "..." --description 'literal text with \`optimus setup\` inside'`,
-        `Example: printf '%s' 'literal text with \`optimus setup\` inside' | optimus ${command} --title "..." --description-stdin`
+        ...(command === "submit"
+            ? [
+                `Example: optimus submit --title "..." --file ./task.md`,
+                `Example: optimus submit --url https://mi.feishu.cn/docx/ABC123`
+            ]
+            : [`Example: printf '%s' 'literal text with \`optimus setup\` inside' | optimus feedback --title "..." --description-stdin`])
     ].join("\n");
 }
+function isFeishuDocumentUrl(value) {
+    return /^https?:\/\/(?:[\w-]+\.)?feishu\.cn\//iu.test(value.trim())
+        || /^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;
+}
+function parseHtmlAttributeMap(fragment) {
+    const attributes = {};
+    const pattern = /([\w:-]+)="([^"]*)"/gu;
+    let match;
+    while ((match = pattern.exec(fragment)) !== null) {
+        const key = match[1];
+        const value = match[2];
+        if (key !== undefined && value !== undefined) {
+            attributes[key] = value;
+        }
+    }
+    return attributes;
+}
+function extractFeishuReferenceMaterials(markdown, media, sourceUrl) {
+    const references = [];
+    const seen = new Set();
+    let embeddedImageCount = 0;
+    let embeddedWhiteboardCount = 0;
+    let embeddedDocCount = 0;
+    let embeddedSheetCount = 0;
+    let embeddedBitableCount = 0;
+    let embeddedFileCount = 0;
+    let rawLinkCount = 0;
+    const pushReference = (reference) => {
+        const identityParts = [
+            reference.type,
+            reference.url ?? "",
+            reference.token ?? "",
+            reference.content ?? ""
+        ];
+        const key = identityParts.some((part) => part.length > 0)
+            ? identityParts.join("|")
+            : [reference.type, reference.title].join("|");
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        references.push(reference);
+    };
+    if (Array.isArray(media)) {
+        for (const entry of media) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                continue;
+            }
+            const record = entry;
+            const token = typeof record.token === "string" ? record.token.trim() : "";
+            const type = typeof record.type === "string" ? record.type.trim() : "";
+            if (!token || !type) {
+                continue;
+            }
+            if (type === "whiteboard") {
+                embeddedWhiteboardCount += 1;
+                pushReference({
+                    type: "whiteboard",
+                    title: `Embedded whiteboard ${embeddedWhiteboardCount}`,
+                    token,
+                    sourceType: "feishu_media"
+                });
+                continue;
+            }
+            embeddedFileCount += 1;
+            pushReference({
+                type: "file",
+                title: `Embedded ${type} ${embeddedFileCount}`,
+                token,
+                sourceType: "feishu_media"
+            });
+        }
+    }
+    const markdownImagePattern = /!\[(.*?)\]\((https?:\/\/[^)\s]+)\)/gu;
+    let imageMatch;
+    while ((imageMatch = markdownImagePattern.exec(markdown)) !== null) {
+        embeddedImageCount += 1;
+        const alt = imageMatch[1]?.trim();
+        const imageUrl = imageMatch[2]?.trim();
+        if (!imageUrl) {
+            continue;
+        }
+        pushReference({
+            type: "image",
+            title: alt || `Embedded image ${embeddedImageCount}`,
+            url: imageUrl,
+            sourceType: "feishu_markdown"
+        });
+    }
+    const htmlImagePattern = /<img\b([^>]*)\/?>/gu;
+    let htmlImageMatch;
+    while ((htmlImageMatch = htmlImagePattern.exec(markdown)) !== null) {
+        embeddedImageCount += 1;
+        const attrs = parseHtmlAttributeMap(htmlImageMatch[1] ?? "");
+        pushReference({
+            type: "image",
+            title: attrs.name?.trim() || `Embedded image ${embeddedImageCount}`,
+            ...(attrs.src?.trim() ? { token: attrs.src.trim() } : {}),
+            ...(attrs.mime?.trim() ? { mimeType: attrs.mime.trim() } : {}),
+            sourceType: "feishu_markdown"
+        });
+    }
+    const whiteboardPattern = /<whiteboard\b([^>]*)>(?:<\/whiteboard>)?/gu;
+    let whiteboardMatch;
+    while ((whiteboardMatch = whiteboardPattern.exec(markdown)) !== null) {
+        embeddedWhiteboardCount += 1;
+        const attrs = parseHtmlAttributeMap(whiteboardMatch[1] ?? "");
+        pushReference({
+            type: "whiteboard",
+            title: `Embedded whiteboard ${embeddedWhiteboardCount}`,
+            ...(attrs.token?.trim() ? { token: attrs.token.trim() } : {}),
+            sourceType: "feishu_markdown"
+        });
+    }
+    const citeDocPattern = /<cite\b([^>]*)><\/cite>/gu;
+    let citeMatch;
+    while ((citeMatch = citeDocPattern.exec(markdown)) !== null) {
+        const attrs = parseHtmlAttributeMap(citeMatch[1] ?? "");
+        if (attrs.type !== "doc") {
+            continue;
+        }
+        const fileType = attrs["file-type"]?.trim();
+        const title = attrs.title?.trim();
+        const token = attrs["doc-id"]?.trim();
+        const referenceType = fileType === "wiki" || fileType === "docx"
+            ? "doc"
+            : fileType === "sheet"
+                ? "sheet"
+                : "doc";
+        if (referenceType === "sheet") {
+            embeddedSheetCount += 1;
+        }
+        else {
+            embeddedDocCount += 1;
+        }
+        pushReference({
+            type: referenceType,
+            title: title || (referenceType === "sheet" ? `Referenced sheet ${embeddedSheetCount}` : `Referenced document ${embeddedDocCount}`),
+            ...(token ? { token } : {}),
+            sourceType: "feishu_cite"
+        });
+    }
+    const sheetPattern = /<sheet\b([^>]*)\/?>/gu;
+    let sheetMatch;
+    while ((sheetMatch = sheetPattern.exec(markdown)) !== null) {
+        embeddedSheetCount += 1;
+        const attrs = parseHtmlAttributeMap(sheetMatch[1] ?? "");
+        pushReference({
+            type: "sheet",
+            title: `Embedded sheet ${embeddedSheetCount}`,
+            ...(attrs.token?.trim() ? { token: attrs.token.trim() } : {}),
+            sourceType: "feishu_markdown"
+        });
+    }
+    const bitablePattern = /<bitable\b([^>]*)\/?>/gu;
+    let bitableMatch;
+    while ((bitableMatch = bitablePattern.exec(markdown)) !== null) {
+        embeddedBitableCount += 1;
+        const attrs = parseHtmlAttributeMap(bitableMatch[1] ?? "");
+        pushReference({
+            type: "bitable",
+            title: `Embedded bitable ${embeddedBitableCount}`,
+            ...(attrs.token?.trim() ? { token: attrs.token.trim() } : {}),
+            sourceType: "feishu_markdown"
+        });
+    }
+    const filePattern = /<file\b([^>]*)\/?>/gu;
+    let fileMatch;
+    while ((fileMatch = filePattern.exec(markdown)) !== null) {
+        embeddedFileCount += 1;
+        const attrs = parseHtmlAttributeMap(fileMatch[1] ?? "");
+        pushReference({
+            type: "file",
+            title: attrs.name?.trim() || `Embedded file ${embeddedFileCount}`,
+            ...(attrs.token?.trim() ? { token: attrs.token.trim() } : {}),
+            sourceType: "feishu_markdown"
+        });
+    }
+    const rawUrlPattern = /https?:\/\/[^\s<>"')]+/gu;
+    let urlMatch;
+    while ((urlMatch = rawUrlPattern.exec(markdown)) !== null) {
+        const link = urlMatch[0];
+        if (link === sourceUrl || /https?:\/\/(?:[\w-]+\.)?feishu\.cn\/file\//iu.test(link)) {
+            continue;
+        }
+        rawLinkCount += 1;
+        pushReference({
+            type: "link",
+            title: rawLinkCount === 1 ? "Referenced link" : `Referenced link ${rawLinkCount}`,
+            url: link,
+            sourceType: "feishu_markdown"
+        });
+    }
+    return references.length > 0 ? references : undefined;
+}
+async function resolveTaskTextFromUrl(url) {
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) {
+        throw new Error("Task document URL is empty.");
+    }
+    if (!isFeishuDocumentUrl(trimmedUrl)) {
+        throw new Error("submit currently supports document URLs from Feishu/Lark only.");
+    }
+    let stdout;
+    try {
+        const result = await execFileAsync("feishu", ["fetch", trimmedUrl], {
+            maxBuffer: 10 * 1024 * 1024
+        });
+        stdout = result.stdout;
+    }
+    catch (error) {
+        const execError = error;
+        if (execError?.code === "ENOENT") {
+            throw new Error("submit could not fetch the Feishu document because the `feishu` CLI is not installed or not on PATH.");
+        }
+        const detail = execError?.stderr?.trim() || execError?.stdout?.trim() || execError?.message || "unknown error";
+        throw new Error(`submit could not fetch the Feishu document: ${detail}`);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("submit received non-JSON output from `feishu fetch`.");
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        throw new Error("submit received an invalid response from `feishu fetch`.");
+    }
+    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.");
+    }
+    return {
+        content: markdown,
+        ...(title ? { title } : {}),
+        sourceType: "feishu_doc",
+        ...(sourceDocumentType ? { sourceDocumentType } : {}),
+        ...(referenceMaterials ? { referenceMaterials } : {})
+    };
+}
 async function main() {
     const argv = process.argv.slice(2);
     const [firstArg, ...rest] = argv;
@@ -2474,19 +2774,57 @@ async function main() {
     }
     if (command === "submit") {
         const args = parseArgs(commandArgs);
-        const title = args.title?.trim();
-        const description = await resolveLongTextArg(args, {
-            inline: ["desc", "description"],
-            file: "description-file",
-            stdin: "description-stdin"
-        });
-        if (!title || !description) {
+        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();
+        const inputSourceCount = [inlineDescription, filePath, url].filter(Boolean).length;
+        if (inputSourceCount !== 1) {
+            console.error(renderShellQuotingHint("submit"));
+            process.exitCode = 1;
+            return;
+        }
+        let description = "";
+        let resolvedTitle = explicitTitle;
+        let remoteSourceType;
+        let remoteDocumentTitle;
+        let remoteDocumentType;
+        let referenceMaterials;
+        if (inlineDescription) {
+            description = inlineDescription;
+        }
+        else if (filePath) {
+            description = (await readFile(filePath, "utf8")).trim();
+        }
+        else {
+            try {
+                const remote = await resolveTaskTextFromUrl(url);
+                description = remote.content;
+                resolvedTitle = resolvedTitle || remote.title;
+                remoteSourceType = remote.sourceType;
+                remoteDocumentTitle = remote.title;
+                remoteDocumentType = remote.sourceDocumentType;
+                referenceMaterials = remote.referenceMaterials;
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!resolvedTitle || !description) {
+            console.error(renderShellQuotingHint("submit"));
+            process.exitCode = 1;
+            return;
+        }
+        if (!description) {
             console.error(renderShellQuotingHint("submit"));
             process.exitCode = 1;
             return;
         }
         await store.init();
-        const repositorySelection = await resolveSubmissionRepositorySelector(args, store, config);
+        const repositorySelection = await resolveSubmissionRepositorySelector(taskType, args, store, config);
         if (!repositorySelection.ok) {
             console.error(repositorySelection.reason);
             process.exitCode = 1;
@@ -2494,11 +2832,18 @@ async function main() {
         }
         const event = createManualProblemEvent({
             ...args,
+            title: resolvedTitle,
+            description,
+            ...(url ? { sourceUrl: url } : {}),
+            ...(remoteSourceType ? { "source-type": remoteSourceType } : {}),
+            ...(remoteDocumentTitle ? { "source-document-title": remoteDocumentTitle } : {}),
+            ...(remoteDocumentType ? { "source-document-type": remoteDocumentType } : {}),
+            ...(referenceMaterials ? { "reference-materials-json": JSON.stringify(referenceMaterials) } : {}),
             ...(repositorySelection.repoSelector ? { repo: repositorySelection.repoSelector } : {}),
             ...(args["allow-duplicate"] === "true" ? { "allow-duplicate": "true" } : {})
         });
-        const inboxPath = await runtime.writeManualSubmission(event);
-        console.log(`[optimus] wrote submission ${inboxPath}`);
+        await runtime.writeManualSubmission(event);
+        console.log("[optimus] submit succeeded");
         return;
     }
     if (command === "feedback") {
@@ -3405,7 +3750,11 @@ async function inspectBuiltinSkills(config, skillSyncService) {
         evolutionTaskLevelSkills
     };
 }
-async function resolveSubmissionRepositorySelector(args, store, config) {
+async function resolveSubmissionRepositorySelector(taskType, args, store, config) {
+    const runtimePolicy = getTaskRuntimePolicy(taskType);
+    if (!runtimePolicy.requiresRepository) {
+        return { ok: true };
+    }
     const candidates = await listCliRepositoryCandidates(store, config);
     const requestedRepo = args.repo?.trim();
     if (requestedRepo) {