@chenpengfei/daily-brief 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes for Formal Releases are recorded here. GitHub Release notes should be derived from the matching version entry.
 
+## 0.1.2 - 2026-06-04
+
+Patch release for the simplified public CLI setup workflow.
+
+### User-visible Changes
+
+- Simplifies the public CLI around `setup`, `run-once`, `status`, `sources`, `version`, and help.
+- Reworks `daily-brief setup` into an interactive wizard that preserves existing files by default and guides model credential and optional Discord delivery configuration.
+- Adds human-readable `run-once` progress output and clearer Source listing/edit guidance.
+- Makes `delivery.enabled: false` take precedence over `DISCORD_WEBHOOK_URL`, preventing accidental Discord sends when delivery is disabled in config.
+
+### Installation and Upgrade Notes
+
+- Upgrade with `npm install -g @chenpengfei/daily-brief@latest`.
+- Run `daily-brief setup` again after upgrading to review the simplified setup flow.
+- Non-interactive setup now fails before writing configuration files; scripted environments should write `config.yaml`, `sources.yaml`, and `auth.json` directly.
+
+### Known Limitations
+
+- The simplified public CLI removes direct public `collect`, `generate`, `deliver`, `model`, and `delivery` command entry points. Use `setup`, `run-once`, `status`, and `sources` for normal installed usage.
+
 ## 0.1.1 - 2026-06-01
 
 Patch release for first-install command discovery.

package/README.md

@@ -25,8 +25,7 @@ Daily Brief requires Node.js 22 or newer.
 daily-brief run-once
 daily-brief status
 daily-brief sources list
-daily-brief model status
-daily-brief delivery status
+daily-brief version
 ```
 
 For installation, setup, configuration, upgrade, and troubleshooting, see `docs/user-manual.md`.

package/dist/src/agent/daily-brief-agent.js

@@ -17,6 +17,7 @@ export async function runOnce(options = {}) {
     const dateKey = options.dateKey;
     let collection;
     try {
+        options.onProgress?.("1/5 Collecting Source Items");
         collection = await collectSources({
             date,
             ...(dateKey ? { dateKey } : {}),
@@ -24,6 +25,9 @@ export async function runOnce(options = {}) {
             ...(options.sourceRegistryPath ? { sourceRegistryPath: options.sourceRegistryPath } : {}),
             ...(options.sourceItemRoot ? { sourceItemRoot: options.sourceItemRoot } : {})
         });
+        for (const source of collection.sources) {
+            options.onProgress?.(`- ${source.sourceId}: ${source.status}, items ${source.itemCount}, written ${source.writtenCount}, duplicates ${source.skippedDuplicateCount}${source.reason ? `, ${source.reason}` : ""}`);
+        }
     }
     catch (error) {
         const coreFailure = {
@@ -32,6 +36,7 @@ export async function runOnce(options = {}) {
         };
         const delivery = await deliverCoreFailureNotification(coreFailure, {
             ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+            ...(options.discordEnv ? { env: options.discordEnv } : {}),
             ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
         });
         return {
@@ -50,6 +55,7 @@ export async function runOnce(options = {}) {
     if (collectionFailure) {
         const delivery = await deliverCoreFailureNotification(collectionFailure, {
             ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+            ...(options.discordEnv ? { env: options.discordEnv } : {}),
             ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
         });
         return {
@@ -64,6 +70,7 @@ export async function runOnce(options = {}) {
         };
     }
     const collectionFailures = collectionFailureRefs(collection);
+    options.onProgress?.("2/5 Generating Daily Brief");
     const generated = await generateOnce({
         ...options,
         ...(dateKey ? { dateKey } : {}),
@@ -75,6 +82,7 @@ export async function runOnce(options = {}) {
             }
             : {})
     });
+    options.onProgress?.("4/5 Delivering Notification");
     const delivery = await deliverOnce({
         ...options,
         date,
@@ -124,6 +132,7 @@ export async function generateOnce(options = {}) {
         const collectionInputRefs = options.collectionFailures
             ? { collectionFailures: options.collectionFailures }
             : undefined;
+        options.onProgress?.("- Understanding Source Items");
         const understanding = await runSourceItemUnderstandingStage({
             sourceItems,
             modelRuntimeConfig,
@@ -131,6 +140,7 @@ export async function generateOnce(options = {}) {
             ...(collectionInputRefs ? { inputRefs: collectionInputRefs } : {}),
             ...(options.modelRuntimeEnv ? { modelRuntimeEnv: options.modelRuntimeEnv } : {})
         });
+        options.onProgress?.("- Selecting and Ranking Signals");
         const selected = await runSignalSelectionAndRankingStages({
             sourceItems,
             annotations: understanding.annotations,
@@ -147,6 +157,7 @@ export async function generateOnce(options = {}) {
             signals: selected.signals
         };
         const narrativeEvents = [];
+        options.onProgress?.("- Writing Narrative");
         const narrative = await enrichDailyBriefNarrativeWithAgent({
             brief: selectedBrief,
             sourceItems,
@@ -161,6 +172,7 @@ export async function generateOnce(options = {}) {
             brief: narrative.brief,
             ...(options.collectionFailures ? { collectionFailures: options.collectionFailures } : {})
         });
+        options.onProgress?.("- Checking Source Grounding");
         const audited = await auditBriefWithSingleRepairAttempt({
             narrativeBrief: narrative.brief,
             sourceItems,
@@ -175,6 +187,7 @@ export async function generateOnce(options = {}) {
         const writtenArtifact = options.agentRunRoot ? await writeAgentRunArtifact(artifact, date, options.agentRunRoot, dateKey) : undefined;
         const markdown = renderDailyBriefMarkdown(audited.brief);
         const piResult = await renderBriefThroughPiRuntime(markdown);
+        options.onProgress?.("3/5 Archiving Daily Brief");
         const archived = await writeBriefArchive(piResult.markdown, date, options.archiveRoot, dateKey);
         return {
             archivePath: archived.path,
@@ -309,6 +322,7 @@ export async function deliverOnce(options = {}) {
         ...(options.discordTemplatePath ? { templatePath: options.discordTemplatePath } : {})
     }, {
         ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+        ...(options.discordEnv ? { env: options.discordEnv } : {}),
         ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
     });
 }

package/dist/src/agent/model-runtime-config.js

@@ -17,7 +17,7 @@ export function readModelRuntimeConfig(env = process.env, options = {}) {
             model: "gpt-5.5",
             credentialRef: "openai-codex.default",
             ready: false,
-            issues: [`Model config not found: ${configPath}. Run daily-brief setup and daily-brief model configure/login first.`]
+            issues: [`Model config not found: ${configPath}. Run daily-brief setup or create config.yaml with model settings.`]
         };
     }
     const issues = credentialIssues(config.provider, config.credentialRef, env, authPath);

package/dist/src/cli.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { stdin as processStdin, stdout as processStdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { deliverOnce, generateOnce, loginModelCredential, logoutModelCredential, readModelRuntimeConfig, runOnce, statusModelCredentials, toApiKeyCredential } from "./agent/index.js";
-import { collectSources } from "./collection/index.js";
+import { stringify } from "yaml";
+import { loginModelCredential, readModelRuntimeConfig, runOnce, toApiKeyCredential } from "./agent/index.js";
 import { resolveConfiguredWebhookUrl } from "./discord/index.js";
-import { defaultModelConfig, dateFromDateKey, formatDateKey, formatSourceRegistry, loadSourceRegistry, putCredential, readDeliveryConfig, readConfiguredTimezone, getCredential, resolveDailyBriefPaths, setSourceEnabled, validateSourceRegistry, writeDeliveryConfig, writeCredentialStore, writeModelConfig } from "./config/index.js";
+import { defaultModelConfig, dateFromDateKey, formatDateKey, formatSourceRegistry, isEnvCredentialRef, loadSourceRegistry, putCredential, readDeliveryConfig, readDailyBriefConfig, readConfiguredTimezone, getCredential, resolveDailyBriefPaths, setSourceEnabled, validateSourceRegistry, writeDeliveryConfig, writeCredentialStore, writeModelConfig } from "./config/index.js";
 import { getOperationalStatus } from "./workflow/index.js";
 const consoleIo = {
+    interactive: Boolean(processStdin.isTTY && processStdout.isTTY),
     stdout(line) {
         console.log(line);
     },
@@ -16,7 +18,10 @@ const consoleIo = {
         console.error(line);
     },
     async prompt(message) {
-        const reader = createInterface({ input: processStdin, output: processStdout });
+        if (!processStdin.isTTY || !processStdout.isTTY) {
+            throw new Error(nonInteractiveSetupMessage());
+        }
+        const reader = createInterface({ input: processStdin, output: processStdout, terminal: false });
         try {
             return await reader.question(`${message} `);
         }
@@ -36,43 +41,38 @@ export async function runCli(args, io = consoleIo, env = process.env) {
         printHelp(io);
         return;
     }
+    if (command === "version" || command === "--version" || command === "-v") {
+        io.stdout(await readPackageVersion());
+        return;
+    }
     if (command === "run-once") {
         await assertWorkflowConfigured(options.sourceRegistryPath);
-        const result = await runOnce(options);
+        io.stdout("Daily Brief run started");
+        io.stdout(`Date: ${options.dateKey}`);
+        io.stdout(`Home: ${resolveDailyBriefPaths(env).home}`);
+        io.stdout("");
+        const result = await runOnce({
+            ...options,
+            onProgress(line) {
+                io.stdout(line);
+            }
+        });
         if (result.coreFailure) {
             throw new Error(`Core Workflow Failure: ${result.coreFailure.kind}\n${result.coreFailure.message}`);
         }
+        io.stdout("");
         io.stdout(`Daily Brief archived: ${result.archivePath}`);
         io.stdout(`Sources read: ${result.sourceCount}`);
         io.stdout(`Source Items read: ${result.sourceItemCount}`);
-        io.stdout(`Discord delivery: ${result.delivery.status}`);
-        io.stdout(`Pi events: ${result.piEvents.join(", ")}`);
+        io.stdout(`Agent stages completed: ${countAgentStageEvents(result.piEvents)}/5`);
+        io.stdout(`Discord delivery: ${formatDeliveryStatus(result.delivery)}`);
+        io.stdout("5/5 Run completed");
         return;
     }
     if (command === "setup") {
         await handleSetupCommand(args.slice(1), io, env);
         return;
     }
-    if (command === "collect") {
-        await assertWorkflowConfigured(options.sourceRegistryPath);
-        const result = await collectSources(options);
-        io.stdout(`Source Item Store: ${result.storePath || "(no items written)"}`);
-        for (const source of result.sources) {
-            io.stdout(`${source.status.padEnd(7)} ${source.sourceId} items=${source.itemCount} written=${source.writtenCount} duplicates=${source.skippedDuplicateCount}${source.reason ? ` reason=${source.reason}` : ""}`);
-        }
-        return;
-    }
-    if (command === "generate") {
-        const result = await generateOnce(options);
-        io.stdout(`Daily Brief archived: ${result.archivePath}`);
-        io.stdout(`Source Items read: ${result.sourceItemCount}`);
-        return;
-    }
-    if (command === "deliver") {
-        const result = await deliverOnce(options);
-        io.stdout(`Discord delivery: ${result.status}${"reason" in result ? ` (${result.reason})` : ""}`);
-        return;
-    }
     if (command === "status") {
         const status = await getOperationalStatus(options);
         io.stdout(`${status.health}: ${status.message}`);
@@ -85,16 +85,37 @@ export async function runCli(args, io = consoleIo, env = process.env) {
         await handleSourcesCommand(subcommand, value, io, options.sourceRegistryPath);
         return;
     }
-    if (command === "model") {
-        await handleModelCommand(args.slice(1), io, env);
-        return;
-    }
-    if (command === "delivery") {
-        await handleDeliveryCommand(args.slice(1), io, env);
-        return;
-    }
     throw new Error(`Unknown command: ${command}`);
 }
+async function readPackageVersion() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let index = 0; index < 8; index += 1) {
+        const path = join(directory, "package.json");
+        try {
+            const packageJson = JSON.parse(await readFile(path, "utf8"));
+            if (isRecord(packageJson) && typeof packageJson.version === "string") {
+                return `daily-brief ${packageJson.version}`;
+            }
+        }
+        catch (error) {
+            if (!(isNodeError(error) && error.code === "ENOENT")) {
+                throw error;
+            }
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            break;
+        }
+        directory = parent;
+    }
+    return "daily-brief unknown";
+}
+function countAgentStageEvents(events) {
+    return events.length > 0 ? 5 : 0;
+}
+function formatDeliveryStatus(delivery) {
+    return `${delivery.status}${delivery.reason ? ` (${delivery.reason})` : ""}`;
+}
 function readWorkflowDateOption(flags, env) {
     if (flags.date) {
         if (!/^\d{4}-\d{2}-\d{2}$/.test(flags.date)) {
@@ -119,8 +140,15 @@ async function handleSourcesCommand(subcommand, value, io, sourceRegistryPath) {
     }
     if (subcommand === "edit") {
         const path = sourceRegistryPath ?? resolveDailyBriefPaths().sourceRegistryPath;
-        io.stdout(`Source Registry: ${path}`);
-        io.stdout("Edit this YAML file, then run: daily-brief sources validate");
+        io.stdout("Source Registry:");
+        io.stdout(`  ${path}`);
+        io.stdout("");
+        io.stdout("Edit this YAML file to add, remove, or update Sources.");
+        io.stdout("Use the id field as SOURCE ID for enable/disable commands.");
+        io.stdout("");
+        io.stdout("After editing:");
+        io.stdout("  daily-brief sources validate");
+        io.stdout("  daily-brief sources list");
         return;
     }
     if (subcommand === "validate") {
@@ -138,10 +166,19 @@ async function handleSourcesCommand(subcommand, value, io, sourceRegistryPath) {
     }
     if (subcommand === "enable" || subcommand === "disable") {
         if (!value) {
-            throw new Error(`sources ${subcommand} requires a Source id`);
+            throw new Error(`sources ${subcommand} requires a SOURCE ID. Run daily-brief sources list to see available SOURCE ID values.`);
         }
         const enabled = subcommand === "enable";
-        await setSourceEnabled(value, enabled, sourceRegistryPath);
+        try {
+            await setSourceEnabled(value, enabled, sourceRegistryPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === `Source not found: ${value}`) {
+                throw new Error(`Source not found: ${value}. Run daily-brief sources list to see available SOURCE ID values.`);
+            }
+            throw error;
+        }
         io.stdout(`${enabled ? "Enabled" : "Disabled"} Source: ${value}`);
         return;
     }
@@ -152,117 +189,229 @@ function printHelp(io) {
         "Daily Brief Operational CLI",
         "",
         "Usage:",
-        "  daily-brief setup [--force]",
-        "  daily-brief run-once",
-        "  daily-brief collect",
-        "  daily-brief generate",
-        "  daily-brief deliver",
+        "  daily-brief setup",
+        "  daily-brief run-once [--date YYYY-MM-DD]",
         "  daily-brief status",
-        "  daily-brief model configure [--provider <provider> --model <model> --credential-ref <ref>]",
-        "  daily-brief model login [--provider openai-codex --credential-ref <ref>]",
-        "  daily-brief model logout [--credential-ref <ref>]",
-        "  daily-brief model status",
-        "  daily-brief delivery configure --enabled true|false [--webhook-ref <ref> --webhook-url <url>]",
-        "  daily-brief delivery status",
-        "  daily-brief delivery test",
         "  daily-brief sources list",
         "  daily-brief sources edit",
         "  daily-brief sources validate",
         "  daily-brief sources enable <source-id>",
-        "  daily-brief sources disable <source-id>"
+        "  daily-brief sources disable <source-id>",
+        "  daily-brief version"
     ].join("\n"));
 }
 async function handleSetupCommand(args, io, env) {
     const flags = parseFlags(args);
-    const force = flags.force === "true";
+    if (Object.keys(flags).length > 0 || args.some((arg) => !arg.startsWith("--"))) {
+        throw new Error("daily-brief setup does not accept flags. Re-run setup and choose what to preserve or update interactively.");
+    }
+    requireInteractiveSetup(io);
     const paths = resolveDailyBriefPaths(env);
-    const timezone = env.TZ?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    const existingConfig = readDailyBriefConfig(paths.configPath);
+    const timezone = await promptWithDefault(io, "Timezone", readConfiguredTimezone(paths.configPath) ?? env.TZ?.trim() ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC");
     await mkdir(paths.home, { recursive: true });
     await mkdir(paths.sourceItemRoot, { recursive: true });
     await mkdir(paths.agentRunRoot, { recursive: true });
     await mkdir(paths.briefArchiveRoot, { recursive: true });
-    await writeIfNeeded(paths.configPath, [
-        `timezone: ${timezone}`,
-        "brief:",
-        "  language: zh",
-        "  maxSignals: 5",
-        "model:",
-        "  provider: openai-codex",
-        "  model: gpt-5.5",
-        "  credentialRef: openai-codex.default",
-        "delivery:",
-        "  enabled: false",
-        ""
-    ].join("\n"), force);
-    await writeIfNeeded(paths.sourceRegistryPath, defaultSourceRegistryExample(), force);
-    if (force || !(await exists(paths.authPath))) {
+    await writeSetupBaseConfig(paths.configPath, {
+        ...existingConfig,
+        timezone,
+        brief: normalizeBriefConfig(existingConfig.brief)
+    });
+    if (!(await exists(paths.authPath))) {
         writeCredentialStore({ credentials: {} }, paths.authPath);
     }
+    if (await exists(paths.sourceRegistryPath)) {
+        io.stdout(`Source Registry: ${paths.sourceRegistryPath}`);
+        try {
+            io.stdout(formatSourceRegistry(await loadSourceRegistry(paths.sourceRegistryPath)));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            io.stdout(`Source Registry invalid:\n${message}`);
+        }
+        const reinitialize = await promptYesNo(io, "Reinitialize example Sources? Existing sources.yaml will be overwritten.", false);
+        if (reinitialize) {
+            await writeFile(paths.sourceRegistryPath, defaultSourceRegistryExample(), "utf8");
+            io.stdout("Source Registry reinitialized from the packaged example.");
+        }
+        else {
+            io.stdout("Source Registry preserved.");
+        }
+    }
+    else {
+        await writeFile(paths.sourceRegistryPath, defaultSourceRegistryExample(), "utf8");
+        io.stdout(`Source Registry initialized: ${paths.sourceRegistryPath}`);
+        io.stdout(formatSourceRegistry(await loadSourceRegistry(paths.sourceRegistryPath)));
+    }
+    io.stdout("To edit Sources:");
+    io.stdout("  daily-brief sources edit");
+    io.stdout("  daily-brief sources validate");
+    io.stdout("  daily-brief sources list");
+    await configureModelThroughSetup(io, env);
+    await configureDeliveryThroughSetup(io, env);
+    const readiness = readModelRuntimeConfig(env);
+    const delivery = readDeliveryConfig(paths.configPath);
     io.stdout(`Daily Brief home: ${paths.home}`);
     io.stdout(`Daily Brief data: ${paths.dataHome}`);
     io.stdout(`Timezone: ${timezone}`);
     io.stdout(`Source Registry: ${paths.sourceRegistryPath}`);
-    io.stdout("Next: daily-brief sources validate");
-    io.stdout("Next: daily-brief model configure");
-    io.stdout("Optional: daily-brief delivery configure --enabled true --webhook-url <url>");
-    io.stdout("Readiness: config files present, Source Registry initialized, data directories writable, delivery disabled");
+    io.stdout(`Model: ${readiness.provider}/${readiness.model}`);
+    io.stdout(`Model credential: ${readiness.ready ? "configured" : "missing"}`);
+    io.stdout(`Discord delivery: ${delivery?.enabled ? "enabled" : "disabled"}`);
+    io.stdout("Ready to run:");
+    io.stdout("  daily-brief run-once");
+}
+function requireInteractiveSetup(io) {
+    if (!io.prompt || io.interactive === false) {
+        throw new Error(nonInteractiveSetupMessage());
+    }
+}
+function nonInteractiveSetupMessage() {
+    return [
+        "daily-brief setup requires an interactive terminal.",
+        "For CI or scripted setup, create ~/.daily-brief/config.yaml, ~/.daily-brief/sources.yaml, and ~/.daily-brief/auth.json directly.",
+        "Use DAILY_BRIEF_HOME to choose a configuration root and DAILY_BRIEF_DATA_HOME to choose a generated-data root.",
+        "Run daily-brief sources validate after writing sources.yaml."
+    ].join("\n");
+}
+async function writeSetupBaseConfig(path, config) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, stringify(config), "utf8");
 }
-async function handleDeliveryCommand(args, io, env) {
-    const [subcommand, ...rest] = args;
-    const flags = parseFlags(rest);
+function normalizeBriefConfig(value) {
+    const current = isRecord(value) ? value : {};
+    return {
+        ...current,
+        language: "zh",
+        maxSignals: typeof current.maxSignals === "number" ? current.maxSignals : 5
+    };
+}
+async function configureModelThroughSetup(io, env) {
     const paths = resolveDailyBriefPaths(env);
-    if (subcommand === "configure") {
-        const enabled = flags.enabled === "true" || flags.enabled === "yes";
-        const webhookRef = flags["webhook-ref"] ?? "discord.default";
-        writeDeliveryConfig({ enabled, ...(enabled ? { webhookRef } : {}) }, paths.configPath);
-        if (enabled && flags["webhook-url"]) {
-            putCredential(webhookRef, { type: "webhook", provider: "discord", webhookUrl: flags["webhook-url"] }, paths.authPath);
-        }
-        io.stdout(`Discord delivery: ${enabled ? "enabled" : "disabled"}`);
-        if (enabled)
-            io.stdout(`Webhook Ref: ${webhookRef}`);
+    const current = readDailyBriefConfig(paths.configPath).model ?? defaultModelConfig();
+    const provider = readProviderFlag(await promptWithDefault(io, "LLM Provider (openai-codex/openai/deepseek/openai-compatible)", current.provider));
+    const model = await promptWithDefault(io, "Model", current.provider === provider ? current.model : defaultModelForProvider(provider));
+    io.stdout("Credential name identifies where Daily Brief finds the model secret. Use the default unless you manage multiple credentials; env:NAME reads an environment variable.");
+    const credentialRef = await promptWithDefault(io, "Model credential name", current.provider === provider ? current.credentialRef ?? defaultCredentialRef(provider) ?? "" : defaultCredentialRef(provider) ?? "");
+    const baseUrl = provider === "openai-compatible"
+        ? await promptWithDefault(io, "Base URL", current.provider === provider ? current.baseUrl ?? "" : "")
+        : undefined;
+    const config = {
+        provider,
+        model,
+        ...(credentialRef ? { credentialRef } : {}),
+        ...(baseUrl ? { baseUrl } : {})
+    };
+    writeModelConfig(config, paths.configPath);
+    io.stdout(`Model configured: ${provider}/${model}`);
+    if (credentialRef) {
+        io.stdout(`Model credential name: ${credentialRef}`);
+    }
+    await maybeConfigureModelCredential({ provider, credentialRef, io, env });
+}
+async function maybeConfigureModelCredential(input) {
+    if (!input.credentialRef) {
         return;
     }
-    if (subcommand === "status") {
-        const config = readDeliveryConfig(paths.configPath);
-        if (!config?.enabled) {
-            io.stdout("Discord delivery: disabled");
+    const paths = resolveDailyBriefPaths(input.env);
+    if (input.provider === "openai-codex") {
+        const credential = getCredential(input.credentialRef, paths.authPath);
+        if (credential) {
+            input.io.stdout("Model credential: configured");
             return;
         }
-        const credential = config.webhookRef ? getDeliveryWebhookCredential(config.webhookRef, paths.authPath) : undefined;
-        io.stdout("Discord delivery: enabled");
-        io.stdout(`Webhook Ref: ${config.webhookRef ?? "(missing)"}`);
-        io.stdout(`Webhook: ${credential ? "<redacted>" : "(missing)"}`);
+        if (await promptYesNo(input.io, "Login to openai-codex now?", true)) {
+            await loginModelCredential({
+                provider: input.provider,
+                credentialRef: input.credentialRef,
+                io: input.io,
+                env: input.env
+            });
+            input.io.stdout(`Logged in credential: ${input.credentialRef}`);
+        }
+        else {
+            input.io.stdout("Model credential: missing");
+        }
         return;
     }
-    if (subcommand === "test") {
-        const config = readDeliveryConfig(paths.configPath);
-        const credential = config?.webhookRef ? getDeliveryWebhookCredential(config.webhookRef, paths.authPath) : undefined;
-        if (!config?.enabled || !credential) {
-            throw new Error("delivery test requires enabled Discord delivery with a webhook credential");
+    if (isEnvCredentialRef(input.credentialRef)) {
+        const hasEnvValue = Boolean(input.env[input.credentialRef.slice("env:".length)]?.trim());
+        if (hasEnvValue) {
+            input.io.stdout("Model credential: configured from environment");
+            return;
         }
-        const response = await (io.fetchImpl ?? fetch)(credential.webhookUrl, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ content: "Daily Brief delivery test" })
-        });
-        if (!response.ok) {
-            throw new Error(`Discord delivery test failed with status ${response.status}`);
+        if (!(await promptYesNo(input.io, "Store API key in credential store instead of using the environment?", false))) {
+            input.io.stdout("Model credential: missing until the environment variable is set");
+            return;
+        }
+        const storedRef = await promptWithDefault(input.io, "Stored credential name", `${input.provider}.default`);
+        const apiKey = await promptWithDefault(input.io, "API key input may be visible in this terminal. API key", "");
+        if (apiKey) {
+            putCredential(storedRef, toApiKeyCredential(input.provider, apiKey), paths.authPath);
+            writeModelConfig({ ...readDailyBriefConfig(paths.configPath).model, credentialRef: storedRef }, paths.configPath);
+            input.io.stdout(`Stored credential: ${storedRef}`);
         }
-        io.stdout("Discord delivery test: sent");
         return;
     }
-    throw new Error(`Unknown delivery command: ${subcommand ?? "(missing)"}`);
-}
-function getDeliveryWebhookCredential(ref, authPath) {
-    const credential = getCredential(ref, authPath);
-    return credential?.type === "webhook" && credential.provider === "discord" ? credential : undefined;
+    if (getCredential(input.credentialRef, paths.authPath)) {
+        input.io.stdout("Model credential: configured");
+        return;
+    }
+    if (await promptYesNo(input.io, "Store API key in credential store? API key input may be visible in this terminal.", false)) {
+        const apiKey = await promptWithDefault(input.io, "API key", "");
+        if (apiKey) {
+            putCredential(input.credentialRef, toApiKeyCredential(input.provider, apiKey), paths.authPath);
+            input.io.stdout(`Stored credential: ${input.credentialRef}`);
+        }
+    }
+    else {
+        input.io.stdout("Model credential: missing");
+    }
 }
-async function writeIfNeeded(path, contents, force) {
-    if (!force && (await exists(path))) {
+async function configureDeliveryThroughSetup(io, env) {
+    const paths = resolveDailyBriefPaths(env);
+    const current = readDeliveryConfig(paths.configPath);
+    const enabled = await promptYesNo(io, "Enable Discord delivery?", current?.enabled ?? false);
+    if (!enabled) {
+        writeDeliveryConfig({ enabled: false }, paths.configPath);
+        io.stdout("Discord delivery: disabled");
         return;
     }
-    await writeFile(path, contents, "utf8");
+    const webhookRef = await promptWithDefault(io, "Discord webhook credential name", current?.webhookRef ?? "discord.default");
+    writeDeliveryConfig({ enabled: true, webhookRef }, paths.configPath);
+    const credential = getCredential(webhookRef, paths.authPath);
+    if (credential) {
+        io.stdout("Discord webhook: configured");
+        if (!(await promptYesNo(io, "Replace Discord webhook URL?", false))) {
+            return;
+        }
+    }
+    const webhookUrl = await promptWithDefault(io, "Discord webhook URL", "");
+    if (webhookUrl) {
+        putCredential(webhookRef, { type: "webhook", provider: "discord", webhookUrl }, paths.authPath);
+        io.stdout(`Discord webhook stored: ${webhookRef}`);
+    }
+    else {
+        io.stdout("Discord webhook: missing");
+    }
+}
+async function promptYesNo(io, label, defaultValue) {
+    if (!io.prompt) {
+        throw new Error(nonInteractiveSetupMessage());
+    }
+    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+    const answer = (await io.prompt(`${label} ${suffix}:`)).trim().toLowerCase();
+    if (!answer) {
+        return defaultValue;
+    }
+    if (answer === "y" || answer === "yes" || answer === "true") {
+        return true;
+    }
+    if (answer === "n" || answer === "no" || answer === "false") {
+        return false;
+    }
+    throw new Error(`${label} requires y/yes or n/no`);
 }
 async function exists(path) {
     try {
@@ -293,71 +442,6 @@ function defaultSourceRegistryExample() {
         ""
     ].join("\n");
 }
-async function handleModelCommand(args, io, env) {
-    const [subcommand, ...rest] = args;
-    const flags = parseFlags(rest);
-    if (subcommand === "configure") {
-        await configureModel(flags, io, env);
-        return;
-    }
-    if (subcommand === "status") {
-        const config = readModelRuntimeConfig(env);
-        io.stdout(`Provider: ${config.provider}`);
-        io.stdout(`Model: ${config.model}`);
-        io.stdout(`Credential Ref: ${config.credentialRef ?? "(none)"}`);
-        io.stdout(`Ready: ${config.ready ? "yes" : "no"}`);
-        for (const issue of config.issues) {
-            io.stdout(`- ${issue}`);
-        }
-        for (const credential of statusModelCredentials(env)) {
-            io.stdout(`Credential: ${credential.ref} provider=${credential.provider} type=${credential.type} secret=${credential.secret}`);
-        }
-        return;
-    }
-    if (subcommand === "login") {
-        const config = readModelRuntimeConfig(env);
-        const provider = readProviderFlag(flags.provider ?? config.provider ?? defaultModelConfig().provider);
-        const credentialRef = flags["credential-ref"] ?? config.credentialRef ?? defaultCredentialRef(provider);
-        if (!credentialRef) {
-            throw new Error("model login requires --credential-ref");
-        }
-        await loginModelCredential({ provider, credentialRef, io, env });
-        io.stdout(`Logged in credential: ${credentialRef}`);
-        return;
-    }
-    if (subcommand === "logout") {
-        const config = readModelRuntimeConfig(env);
-        const credentialRef = flags["credential-ref"] ?? rest[0] ?? config.credentialRef;
-        if (!credentialRef) {
-            throw new Error("model logout requires --credential-ref");
-        }
-        logoutModelCredential(credentialRef, env);
-        io.stdout(`Logged out credential: ${credentialRef}`);
-        return;
-    }
-    throw new Error(`Unknown model command: ${subcommand ?? "(missing)"}`);
-}
-async function configureModel(flags, io, env) {
-    const interactive = Object.keys(flags).length === 0;
-    const provider = readProviderFlag(flags.provider ??
-        (interactive ? await promptWithDefault(io, "Provider", defaultModelConfig().provider) : missingFlag("provider")));
-    const model = flags.model ?? (interactive ? await promptWithDefault(io, "Model", defaultModelForProvider(provider)) : missingFlag("model"));
-    const credentialRef = flags["credential-ref"] ??
-        (interactive ? await promptWithDefault(io, "Credential ref", defaultCredentialRef(provider) ?? "") : missingFlag("credential-ref"));
-    const baseUrl = flags["base-url"] ?? (provider === "openai-compatible" && interactive ? await promptWithDefault(io, "Base URL", "") : undefined);
-    const config = {
-        provider,
-        model,
-        credentialRef,
-        ...(baseUrl ? { baseUrl } : {})
-    };
-    writeModelConfig(config, resolveDailyBriefPaths(env).configPath);
-    if (flags["api-key"]) {
-        putCredential(credentialRef, toApiKeyCredential(provider, flags["api-key"]), resolveDailyBriefPaths(env).authPath);
-    }
-    io.stdout(`Model configured: ${provider}/${model}`);
-    io.stdout(`Credential Ref: ${credentialRef}`);
-}
 function parseFlags(args) {
     const flags = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -427,14 +511,11 @@ function defaultCredentialRef(provider) {
 }
 async function promptWithDefault(io, label, defaultValue) {
     if (!io.prompt) {
-        throw new Error(`model configure requires --${label.toLowerCase().replaceAll(" ", "-")}`);
+        throw new Error(nonInteractiveSetupMessage());
     }
     const answer = await io.prompt(`${label}${defaultValue ? ` (${defaultValue})` : ""}:`);
     return answer.trim() || defaultValue;
 }
-function missingFlag(name) {
-    throw new Error(`model configure requires --${name}`);
-}
 function optionsFromEnv(env) {
     const paths = resolveDailyBriefPaths(env);
     const discordWebhookUrl = resolveConfiguredWebhookUrl(env);
@@ -444,6 +525,7 @@ function optionsFromEnv(env) {
         agentRunRoot: paths.agentRunRoot,
         archiveRoot: paths.briefArchiveRoot,
         modelRuntimeEnv: env,
+        discordEnv: env,
         ...(discordWebhookUrl ? { discordWebhookUrl } : {}),
         ...(env.DAILY_BRIEF_DISCORD_TEMPLATE_PATH ? { discordTemplatePath: env.DAILY_BRIEF_DISCORD_TEMPLATE_PATH } : {})
     };
@@ -496,6 +578,9 @@ function unquoteDotenvValue(value) {
 function isNodeError(error) {
     return error instanceof Error && "code" in error;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 export async function isCliEntrypoint(argvPath, moduleUrl = import.meta.url) {
     if (!argvPath) {
         return false;

package/dist/src/config/source-registry.js

@@ -37,12 +37,35 @@ export async function setSourceEnabled(id, enabled, path = resolveDailyBriefPath
 }
 export function formatSourceRegistry(registry) {
     if (registry.sources.length === 0) {
-        return "No Sources configured.";
+        return [
+            "No Sources configured.",
+            "",
+            "Add Sources by editing the Source Registry, then run:",
+            "  daily-brief sources edit",
+            "  daily-brief sources validate"
+        ].join("\n");
     }
-    return registry.sources
-        .map((source) => {
-        const state = source.enabled ? "enabled" : "disabled";
-        return `${state.padEnd(8)} ${source.id} ${source.platform}/${source.adapter} ${source.target}`;
-    })
-        .join("\n");
+    const rows = registry.sources.map((source) => ({
+        sourceId: source.id,
+        status: source.enabled ? "enabled" : "disabled",
+        platform: source.platform,
+        adapter: source.adapter,
+        target: source.target
+    }));
+    const widths = {
+        sourceId: Math.max("SOURCE ID".length, ...rows.map((row) => row.sourceId.length)),
+        status: Math.max("STATUS".length, ...rows.map((row) => row.status.length)),
+        platform: Math.max("PLATFORM".length, ...rows.map((row) => row.platform.length)),
+        adapter: Math.max("ADAPTER".length, ...rows.map((row) => row.adapter.length))
+    };
+    const firstSourceId = rows[0]?.sourceId ?? "<source-id>";
+    const lines = [
+        `${"SOURCE ID".padEnd(widths.sourceId)}  ${"STATUS".padEnd(widths.status)}  ${"PLATFORM".padEnd(widths.platform)}  ${"ADAPTER".padEnd(widths.adapter)}  TARGET`,
+        ...rows.map((row) => `${row.sourceId.padEnd(widths.sourceId)}  ${row.status.padEnd(widths.status)}  ${row.platform.padEnd(widths.platform)}  ${row.adapter.padEnd(widths.adapter)}  ${row.target}`),
+        "",
+        "Use SOURCE ID with:",
+        `  daily-brief sources enable ${firstSourceId}`,
+        `  daily-brief sources disable ${firstSourceId}`
+    ];
+    return lines.join("\n");
 }

package/dist/src/discord/delivery.js

@@ -62,11 +62,14 @@ async function readDiscordTemplate(templatePath) {
     throw lastError instanceof Error ? lastError : new Error("Discord notification template not found");
 }
 export function resolveConfiguredWebhookUrl(env = process.env) {
+    const paths = resolveDailyBriefPaths(env);
+    const config = readDeliveryConfig(paths.configPath);
+    if (config?.enabled === false) {
+        return undefined;
+    }
     if (env.DISCORD_WEBHOOK_URL) {
         return env.DISCORD_WEBHOOK_URL;
     }
-    const paths = resolveDailyBriefPaths(env);
-    const config = readDeliveryConfig(paths.configPath);
     if (!config?.enabled || !config.webhookRef) {
         return undefined;
     }

package/docs/operations.md

@@ -13,21 +13,18 @@ daily-brief status
 Development usage from a repository checkout uses `npm run cli --`:
 
 ```bash
-npm run cli -- collect
-npm run cli -- generate
-npm run cli -- deliver
 npm run cli -- status
 npm run cli -- run-once
+npm run cli -- --version
 ```
 
 Expected local cadence:
 
-- 06:00 local time: run `collect`.
-- 07:00 local time: run `run-once` or `generate` followed by `deliver`.
+- Run `daily-brief run-once` once per Daily Brief Cadence window.
 
 Scheduler integration is intentionally deployment-neutral. A local cron, launchd job, systemd timer, GitHub Actions workflow, or another scheduler can call the commands above; the repository does not bind the MVP to a specific host.
 
-`run-once` executes collection, brief generation/archive, and Discord delivery in order. Source Item writes are deduplicated by Source Item id and content hash within the daily JSONL store, and Daily Brief generation merges repeated mentions into one multi-citation Signal, so rerunning the workflow for the same Collection Window does not duplicate equivalent Signals.
+`run-once` executes collection, brief generation/archive, and Discord delivery in order. It prints human-readable progress for Source collection, Agent Stage execution, archiving, and delivery while the run is active. Source Item writes are deduplicated by Source Item id and content hash within the daily JSONL store, and Daily Brief generation merges repeated mentions into one multi-citation Signal, so rerunning the workflow for the same Collection Window does not duplicate equivalent Signals.
 
 ## Manual run
 
@@ -41,7 +38,7 @@ npm run cli -- status
 
 `sources list` confirms which Sources are enabled, including the default `github-trending-daily` Source. `run-once` performs collection, brief generation, archive writing, and Discord Delivery once. `status` reports operational health after the run.
 
-Discord Delivery uses `DISCORD_WEBHOOK_URL` from the shell environment or local `.env`; `.env` is loaded automatically by the Operational CLI and does not need to be sourced manually.
+Discord Delivery uses the configured credential reference, or `DISCORD_WEBHOOK_URL` from the shell environment or local `.env`; `.env` is loaded automatically by the Operational CLI and does not need to be sourced manually. An explicit `delivery.enabled: false` in `config.yaml` disables delivery and takes precedence over `DISCORD_WEBHOOK_URL`.
 
 ## Runtime configuration
 
@@ -57,13 +54,10 @@ Installed operational paths can be adjusted through environment variables:
 Model/provider and delivery configuration should normally be managed with:
 
 ```bash
-daily-brief model configure
-daily-brief model status
-daily-brief delivery configure --enabled true --webhook-url <url>
-daily-brief delivery status
+daily-brief setup
 ```
 
-Secrets live in `~/.daily-brief/auth.json` or environment variables, never in `sources.yaml` or committed project files. Installed CLI configuration does not accept the faux provider; faux is reserved for tests through an explicit test-only runtime gate.
+Secrets live in `~/.daily-brief/auth.json` or environment variables, never in `sources.yaml` or committed project files. `daily-brief setup` requires interactive input; CI and scripted environments should create the user configuration files directly under `DAILY_BRIEF_HOME`. Installed CLI configuration does not accept the faux provider; faux is reserved for tests through an explicit test-only runtime gate.
 
 `run-once` does not archive a normal Daily Brief when every enabled Source fails or when no Source Items exist for the requested date. It reports a Core Workflow Failure instead, because a false low-signal brief would hide collection failure.
 

package/docs/user-manual.md

@@ -31,10 +31,14 @@ Run setup after installing the package:
 
 If npm's global bin directory is in `PATH`, `daily-brief setup` is equivalent.
 
-Setup creates user configuration and generated-data directories, initializes the Source Registry from the packaged example, prepares credential storage, and reports readiness. Setup does not collect Sources, call an LLM, generate a Daily Brief, or send a delivery notification.
+Setup is an interactive wizard. It creates user configuration and generated-data directories, initializes the Source Registry from the packaged example, prepares credential storage, guides LLM Provider setup, offers optional Discord Delivery setup, and reports readiness. Setup does not collect Sources, call an LLM, generate a Daily Brief, or send a delivery notification.
+
+Yes/no prompts show the default in brackets: `[y/N]` means pressing Enter chooses no, and `[Y/n]` means pressing Enter chooses yes. You can type `y`, `yes`, `n`, or `no`.
 
 By default, configuration files live under `~/.daily-brief/`, and generated data lives under `~/.daily-brief/data/`.
 
+`daily-brief setup` requires interactive input. For CI or scripted setup, write `config.yaml`, `sources.yaml`, and `auth.json` directly under `DAILY_BRIEF_HOME`, and use `DAILY_BRIEF_DATA_HOME` when generated data should live elsewhere.
+
 ## Configure Sources
 
 Sources are manually controlled. The agent processes configured Sources, but it does not autonomously add or remove them.
@@ -54,25 +58,20 @@ Use `sources validate` after editing the Source Registry.
 Agent Stages require an LLM Provider Configuration before real Daily Brief generation.
 
 ```bash
-daily-brief model configure
-daily-brief model status
-daily-brief model login
-daily-brief model logout
+daily-brief setup
 ```
 
-Credentials are stored in the Model Credential Store or environment variables. Do not put secrets in `sources.yaml` or committed project files.
+Use the setup wizard to choose the provider, model, credential name, and optional login/API key storage path. The credential name is a stable label, such as `openai.default` or `env:OPENAI_API_KEY`, that lets `config.yaml` find the secret in `auth.json` or in the shell environment. Do not put secrets in `sources.yaml` or committed project files.
 
 ## Configure Delivery
 
 Discord Delivery is optional. Configure it when you want generated Daily Brief notifications pushed to Discord.
 
 ```bash
-daily-brief delivery configure --enabled true --webhook-url <url>
-daily-brief delivery status
-daily-brief delivery test
+daily-brief setup
 ```
 
-If Discord Delivery is disabled or no webhook is configured, generation can still run and will report skipped delivery explicitly.
+Setup asks whether to enable Discord Delivery. If Discord Delivery is disabled or no webhook is configured, generation can still run and will report skipped delivery explicitly.
 
 ## Run Daily Brief
 
@@ -82,17 +81,19 @@ For a full manual run:
 daily-brief run-once
 ```
 
-For separated operational steps:
+`run-once` performs collection, Agent Stage generation, archive writing, and delivery once. It prints human-readable progress while the run is active so you can see whether it is collecting Sources, waiting on Agent Stages, archiving, or delivering.
+
+The expected local cadence is a single daily run around the intended delivery time. Daily Brief does not include a built-in scheduler; use an external scheduler to invoke `daily-brief run-once`.
+
+## Version
+
+To report the installed CLI version:
 
 ```bash
-daily-brief collect
-daily-brief generate
-daily-brief deliver
-daily-brief status
+daily-brief version
+daily-brief --version
 ```
 
-The expected local cadence is collection at 06:00 and generation or delivery at 07:00 local time. Daily Brief does not include a built-in scheduler; use an external scheduler to invoke the CLI.
-
 ## Inspect Status
 
 Use status after setup, after manual runs, or when diagnosing failures:
@@ -110,9 +111,9 @@ The installed CLI uses user-home paths by default:
 - `DAILY_BRIEF_HOME`: configuration directory, default `~/.daily-brief`.
 - `DAILY_BRIEF_DATA_HOME`: generated data directory, default `~/.daily-brief/data`.
 - `DAILY_BRIEF_DISCORD_TEMPLATE_PATH`: optional Discord notification template override.
-- `DISCORD_WEBHOOK_URL`: optional Discord webhook URL.
+- `DISCORD_WEBHOOK_URL`: optional Discord webhook URL. If `config.yaml` explicitly sets `delivery.enabled: false`, delivery stays disabled even when this environment variable is present.
 
-Repository checkouts may use a local `.env`; installed usage should normally rely on user configuration and credential commands.
+Repository checkouts may use a local `.env`; installed usage should normally rely on setup, user configuration files, and environment-backed credential references.
 
 ## Upgrade
 
@@ -123,7 +124,7 @@ npm install -g @chenpengfei/daily-brief@latest
 "$(npm prefix -g)/bin/daily-brief" status
 ```
 
-Run `daily-brief setup` again when release notes or status output indicate that configuration needs to be refreshed. Setup preserves existing files unless an overwrite or force behavior is explicitly selected.
+Run `daily-brief setup` again when release notes or status output indicate that configuration needs to be refreshed. Setup preserves existing files by default and asks before replacing non-secret configuration. It does not accept a force-overwrite flag and never deletes generated data.
 
 ## Troubleshooting
 
@@ -149,14 +150,13 @@ daily-brief sources list
 If model access fails, run:
 
 ```bash
-daily-brief model status
+daily-brief setup
 ```
 
 If Discord delivery fails or is skipped, run:
 
 ```bash
-daily-brief delivery status
-daily-brief delivery test
+daily-brief setup
 ```
 
 If a run cannot honestly produce a Daily Brief, the CLI reports a Core Workflow Failure rather than archiving a false normal Daily Brief.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenpengfei/daily-brief",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Agent-driven daily brief CLI for manually curated Agent architecture and AI Coding sources.",
   "private": false,
   "type": "module",