@chenpengfei/daily-brief 0.1.1 → 0.1.3

package/dist/src/config/credential-store.js

@@ -38,9 +38,6 @@ export function removeCredential(ref, path = resolveDailyBriefPaths().authPath)
     return store;
 }
 export function getCredential(ref, path = resolveDailyBriefPaths().authPath) {
-    if (isEnvCredentialRef(ref)) {
-        return undefined;
-    }
     assertStoredCredentialRef(ref);
     return readCredentialStore(path).credentials[ref];
 }
@@ -54,18 +51,9 @@ export function redactCredentialStore(store) {
         }
     ]));
 }
-export function isEnvCredentialRef(ref) {
-    return ref.startsWith("env:") && ref.slice("env:".length).trim().length > 0;
-}
-export function envNameFromCredentialRef(ref) {
-    if (!isEnvCredentialRef(ref)) {
-        throw new Error(`Credential reference is not an env ref: ${ref}`);
-    }
-    return ref.slice("env:".length).trim();
-}
 export function assertStoredCredentialRef(ref) {
-    if (isEnvCredentialRef(ref)) {
-        throw new Error(`Credential reference ${ref} is environment-backed and cannot be stored in auth.json`);
+    if (ref.startsWith("env:")) {
+        throw new Error(`Credential reference ${ref} is not supported; use a stored credential name in auth.json`);
     }
     if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(ref)) {
         throw new Error(`Invalid credentialRef: ${ref}`);

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

@@ -16,10 +16,6 @@ export function readDailyBriefConfig(path = resolveDailyBriefPaths().configPath)
 export function readModelConfig(path = resolveDailyBriefPaths().configPath) {
     return readDailyBriefConfig(path).model;
 }
-export function readConfiguredTimezone(path = resolveDailyBriefPaths().configPath) {
-    const timezone = readDailyBriefConfig(path).timezone;
-    return typeof timezone === "string" && timezone.trim().length > 0 ? timezone.trim() : undefined;
-}
 export function writeModelConfig(config, path = resolveDailyBriefPaths().configPath) {
     const current = readDailyBriefConfig(path);
     const next = {
@@ -72,6 +68,9 @@ export function parseModelConfig(value) {
     if ("apiKey" in value || "secret" in value || "accessToken" in value || "refreshToken" in value) {
         throw new Error("config.model must not contain secrets; use auth.json via credentialRef");
     }
+    if (credentialRef?.startsWith("env:")) {
+        throw new Error("config.model.credentialRef must be a stored credential name, not env:NAME");
+    }
     if (provider === "openai-compatible" && !baseUrl) {
         throw new Error("config.model.baseUrl is required when provider is openai-compatible");
     }
@@ -94,10 +93,11 @@ function readProvider(value) {
     if (provider === "codex" || provider === "hermes") {
         return "openai-codex";
     }
-    if (provider === "faux") {
-        throw new Error("config.model.provider must not be faux; faux is only available through test-only runtime injection");
-    }
-    if (provider === "openai-codex" || provider === "openai" || provider === "deepseek" || provider === "openai-compatible") {
+    if (provider === "faux" ||
+        provider === "openai-codex" ||
+        provider === "openai" ||
+        provider === "deepseek" ||
+        provider === "openai-compatible") {
         return provider;
     }
     throw new Error(`Unsupported model provider: ${provider}`);

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

@@ -22,7 +22,7 @@ export async function deliverCoreFailureNotification(failure, options = {}) {
 async function sendDiscordContent(content, options) {
     const webhookUrl = options.webhookUrl ?? resolveConfiguredWebhookUrl(options.env ?? process.env);
     if (!webhookUrl) {
-        return { status: "skipped", reason: "DISCORD_WEBHOOK_URL is not configured" };
+        return { status: "skipped", reason: "Discord delivery webhook is not configured" };
     }
     try {
         const fetchImpl = options.fetchImpl ?? fetch;
@@ -62,11 +62,11 @@ async function readDiscordTemplate(templatePath) {
     throw lastError instanceof Error ? lastError : new Error("Discord notification template not found");
 }
 export function resolveConfiguredWebhookUrl(env = process.env) {
-    if (env.DISCORD_WEBHOOK_URL) {
-        return env.DISCORD_WEBHOOK_URL;
-    }
     const paths = resolveDailyBriefPaths(env);
     const config = readDeliveryConfig(paths.configPath);
+    if (config?.enabled === false) {
+        return undefined;
+    }
     if (!config?.enabled || !config.webhookRef) {
         return undefined;
     }

package/dist/src/workflow/status.js

@@ -1,6 +1,9 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { loadSourceRegistry, resolveDailyBriefPaths } from "../config/index.js";
+import { constants } from "node:fs";
+import { access, readdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readModelRuntimeConfig } from "../agent/model-runtime-config.js";
+import { formatDateKey, getCredential, loadSourceRegistry, readDeliveryConfig, resolveDailyBriefPaths } from "../config/index.js";
+import { agentRunArtifactPath, readSourceItems, sourceItemStorePath } from "../storage/index.js";
 export function evaluateWorkflowStatus(input) {
     if (input.coreFailure) {
         return {
@@ -50,46 +53,282 @@ export function createCoreWorkflowFailureNotification(failure) {
 }
 export async function getOperationalStatus(options = {}) {
     const date = options.date ?? new Date();
+    const systemTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const dateKey = options.dateKey ?? formatDateKey(date, systemTimezone);
+    const resolvedPaths = resolveDailyBriefPaths(options.env);
+    const paths = {
+        ...resolvedPaths,
+        ...(options.dataHome ? { dataHome: options.dataHome } : {}),
+        ...(options.configPath ? { configPath: options.configPath } : {}),
+        ...(options.authPath ? { authPath: options.authPath } : {}),
+        ...(options.sourceRegistryPath ? { sourceRegistryPath: options.sourceRegistryPath } : {}),
+        ...(options.sourceItemRoot ? { sourceItemRoot: options.sourceItemRoot } : {}),
+        ...(options.agentRunRoot ? { agentRunRoot: options.agentRunRoot } : {}),
+        ...(options.archiveRoot ? { briefArchiveRoot: options.archiveRoot } : {})
+    };
+    const archivePath = briefArchivePath(date, paths.briefArchiveRoot, dateKey);
+    const sourceItemPath = sourceItemStorePath(date, paths.sourceItemRoot, dateKey);
+    const agentRunDirectory = dirname(agentRunArtifactPath(date, "status-probe", paths.agentRunRoot, dateKey));
+    const setup = {
+        config: await inspectConfig(paths.configPath),
+        sourceRegistry: await inspectSourceRegistry(paths.sourceRegistryPath),
+        model: inspectModel(paths.configPath, paths.authPath, options.env),
+        delivery: inspectDelivery(paths.configPath, paths.authPath),
+        data: await inspectDataDirectory(paths.dataHome)
+    };
+    const today = {
+        sourceItems: await inspectSourceItems(date, paths.sourceItemRoot, dateKey, sourceItemPath),
+        briefArchive: await inspectBriefArchive(archivePath),
+        agentRunArtifacts: await inspectAgentRunArtifacts(agentRunDirectory)
+    };
+    const nextAction = chooseNextAction(setup, today);
+    const workflow = summarizeOperationalStatus(dateKey, setup, today);
+    return {
+        ...workflow,
+        dateKey,
+        systemTimezone,
+        paths: {
+            home: paths.home,
+            dataHome: paths.dataHome,
+            configPath: paths.configPath,
+            sourceRegistryPath: paths.sourceRegistryPath,
+            authPath: paths.authPath,
+            sourceItemRoot: paths.sourceItemRoot,
+            agentRunRoot: paths.agentRunRoot,
+            archiveRoot: paths.briefArchiveRoot
+        },
+        setup,
+        today,
+        nextAction
+    };
+}
+function isMaterialPartialFailure(message) {
+    const normalized = message.toLowerCase();
+    const nonMaterialPatterns = ["missing transcript", "transcript missing", "rate limit", "parse failure"];
+    return !nonMaterialPatterns.some((pattern) => normalized.includes(pattern));
+}
+function briefArchivePath(date, root, dateKey) {
+    const datePart = dateKey ?? date.toISOString().slice(0, 10);
+    const [year, month] = datePart.split("-");
+    if (!year || !month) {
+        throw new Error(`Invalid archive date: ${datePart}`);
+    }
+    return join(root, year, month, `${datePart}.md`);
+}
+async function inspectConfig(path) {
+    return (await canRead(path))
+        ? { state: "ok", label: "Config file found", path }
+        : { state: "missing", label: "Config file missing", path };
+}
+async function inspectSourceRegistry(path) {
+    try {
+        const registry = await loadSourceRegistry(path);
+        const enabledCount = registry.sources.filter((source) => source.enabled).length;
+        return {
+            state: "ok",
+            label: "Source Registry valid",
+            path,
+            enabledCount,
+            totalCount: registry.sources.length,
+            detail: `${enabledCount}/${registry.sources.length} enabled`
+        };
+    }
+    catch (error) {
+        return {
+            state: (await canRead(path)) ? "invalid" : "missing",
+            label: (await canRead(path)) ? "Source Registry invalid" : "Source Registry missing",
+            path,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function inspectModel(configPath, authPath, env) {
+    try {
+        const model = readModelRuntimeConfig(env, { configPath, authPath });
+        return {
+            state: model.ready ? "ok" : "not-ready",
+            label: model.ready ? "Model ready" : "Model not ready",
+            path: configPath,
+            provider: model.provider,
+            model: model.model,
+            ...(model.credentialRef ? { credentialRef: model.credentialRef } : {}),
+            ...(model.issues.length > 0 ? { detail: model.issues.join("; ") } : {})
+        };
+    }
+    catch (error) {
+        return {
+            state: "invalid",
+            label: "Model config invalid",
+            path: configPath,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function inspectDelivery(configPath, authPath) {
+    try {
+        const delivery = readDeliveryConfig(configPath);
+        if (!delivery?.enabled) {
+            return { state: "disabled", label: "Discord delivery disabled", path: configPath };
+        }
+        if (!delivery.webhookRef) {
+            return { state: "not-ready", label: "Discord delivery missing webhook credential name", path: configPath };
+        }
+        const credential = getCredential(delivery.webhookRef, authPath);
+        if (!credential) {
+            return {
+                state: "not-ready",
+                label: "Discord delivery webhook credential missing",
+                path: authPath,
+                detail: delivery.webhookRef
+            };
+        }
+        if (credential.type !== "webhook" || credential.provider !== "discord") {
+            return {
+                state: "invalid",
+                label: "Discord delivery credential is not a webhook",
+                path: authPath,
+                detail: delivery.webhookRef
+            };
+        }
+        return { state: "ok", label: "Discord delivery ready", path: authPath, detail: delivery.webhookRef };
+    }
+    catch (error) {
+        return {
+            state: "invalid",
+            label: "Discord delivery config invalid",
+            path: configPath,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+async function inspectDataDirectory(path) {
+    try {
+        await access(path, constants.W_OK);
+        return { state: "ok", label: "Data directory writable", path };
+    }
+    catch (error) {
+        return {
+            state: (await canRead(path)) ? "not-ready" : "missing",
+            label: (await canRead(path)) ? "Data directory is not writable" : "Data directory missing",
+            path,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+async function inspectSourceItems(date, root, dateKey, path) {
     try {
-        await loadSourceRegistry(options.sourceRegistryPath);
+        const items = await readSourceItems(date, root, dateKey);
+        return items.length > 0
+            ? { state: "ok", label: "Source Items found", path, itemCount: items.length, detail: `${items.length} item(s)` }
+            : { state: "missing", label: "No Source Items for today", path, itemCount: 0 };
     }
     catch (error) {
+        return {
+            state: "invalid",
+            label: "Source Items invalid",
+            path,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+async function inspectBriefArchive(path) {
+    return (await canRead(path))
+        ? { state: "ok", label: "Daily Brief archive found", path }
+        : { state: "missing", label: "No Daily Brief archive for today", path };
+}
+async function inspectAgentRunArtifacts(directory) {
+    try {
+        const files = (await readdir(directory)).filter((file) => file.endsWith(".json"));
+        return files.length > 0
+            ? {
+                state: "ok",
+                label: "Agent Run Artifacts found",
+                path: join(directory, files[files.length - 1] ?? ""),
+                fileCount: files.length,
+                detail: `${files.length} artifact(s)`
+            }
+            : { state: "missing", label: "No Agent Run Artifacts for today", path: directory, fileCount: 0 };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return { state: "missing", label: "No Agent Run Artifacts for today", path: directory, fileCount: 0 };
+        }
+        return {
+            state: "invalid",
+            label: "Agent Run Artifacts unreadable",
+            path: directory,
+            detail: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function summarizeOperationalStatus(dateKey, setup, today) {
+    if (setup.sourceRegistry.state === "missing" || setup.sourceRegistry.state === "invalid") {
         return evaluateWorkflowStatus({
             collectionResults: [],
             briefGenerated: false,
             coreFailure: {
                 kind: "unreadable-source-registry",
-                message: error instanceof Error ? error.message : String(error)
+                message: setup.sourceRegistry.detail ?? `${setup.sourceRegistry.label}: ${setup.sourceRegistry.path}`
             }
         });
     }
-    const archivePath = briefArchivePath(date, options.archiveRoot ?? resolveDailyBriefPaths().briefArchiveRoot, options.dateKey);
-    try {
-        await readFile(archivePath, "utf8");
+    const setupReady = setup.config.state === "ok" &&
+        setup.model.state === "ok" &&
+        setup.data.state === "ok" &&
+        (setup.delivery.state === "ok" || setup.delivery.state === "disabled");
+    if (!setupReady) {
+        return {
+            health: "partial-failure",
+            message: "Daily Brief setup is incomplete.",
+            materialPartialFailures: []
+        };
     }
-    catch {
+    if (today.briefArchive.state !== "ok") {
         return {
             health: "partial-failure",
-            message: `No Daily Brief archived for ${options.dateKey ?? date.toISOString().slice(0, 10)} yet.`,
+            message: `No Daily Brief archived for ${dateKey} yet.`,
             materialPartialFailures: []
         };
     }
     return {
         health: "success",
-        message: `Daily Brief archive exists for ${options.dateKey ?? date.toISOString().slice(0, 10)}.`,
+        message: `Daily Brief archive exists for ${dateKey}.`,
         materialPartialFailures: []
     };
 }
-function isMaterialPartialFailure(message) {
-    const normalized = message.toLowerCase();
-    const nonMaterialPatterns = ["missing transcript", "transcript missing", "rate limit", "parse failure"];
-    return !nonMaterialPatterns.some((pattern) => normalized.includes(pattern));
+function chooseNextAction(setup, today) {
+    if (setup.config.state !== "ok") {
+        return "daily-brief setup";
+    }
+    if (setup.sourceRegistry.state !== "ok") {
+        return setup.sourceRegistry.state === "missing" ? "daily-brief setup" : "daily-brief sources validate";
+    }
+    if (setup.sourceRegistry.enabledCount === 0) {
+        return "daily-brief sources list, then daily-brief sources enable <source-id>";
+    }
+    if (setup.model.state !== "ok") {
+        return "daily-brief setup";
+    }
+    if (setup.data.state !== "ok") {
+        return `Check data directory permissions: ${setup.data.path}`;
+    }
+    if (setup.delivery.state === "not-ready" || setup.delivery.state === "invalid") {
+        return "daily-brief setup";
+    }
+    if (today.briefArchive.state !== "ok") {
+        return "daily-brief run-once";
+    }
+    return "No action needed";
 }
-function briefArchivePath(date, root, dateKey) {
-    const datePart = dateKey ?? date.toISOString().slice(0, 10);
-    const [year, month] = datePart.split("-");
-    if (!year || !month) {
-        throw new Error(`Invalid archive date: ${datePart}`);
+async function canRead(path) {
+    try {
+        await access(path, constants.R_OK);
+        return true;
     }
-    return join(root, year, month, `${datePart}.md`);
+    catch {
+        return false;
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
 }

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
 
@@ -39,31 +36,24 @@ npm run cli -- run-once
 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.
+`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 setup readiness, today's run state, active paths, and the next suggested action.
 
-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 in `config.yaml` and `auth.json`. If Discord Delivery is disabled or its webhook credential is missing, delivery is skipped with an explicit reason.
 
 ## Runtime configuration
 
-When the Operational CLI starts, it loads local `.env` values from the repository root if the file exists. Existing shell environment variables take precedence over `.env` values. The `.env` file is ignored by Git; use `.env.example` as the non-secret template.
-
 Installed operational paths can be adjusted through environment variables:
 
 - `DAILY_BRIEF_HOME`: user config directory. Defaults to `~/.daily-brief`.
 - `DAILY_BRIEF_DATA_HOME`: generated data directory. Defaults to `~/.daily-brief/data`.
-- `DAILY_BRIEF_DISCORD_TEMPLATE_PATH`: optional Discord notification template override. Defaults to the packaged Discord notification template.
-- `DISCORD_WEBHOOK_URL`: Discord webhook URL. If unset, Discord Delivery is skipped with an explicit reason.
 
 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`, never in environment variables, `sources.yaml`, `config.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`. Faux provider coverage belongs in test configuration files, not runtime environment variables.
 
 `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`, that lets `config.yaml` find the secret in `auth.json`. Do not put secrets in `sources.yaml`, `config.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:
@@ -101,7 +102,7 @@ Use status after setup, after manual runs, or when diagnosing failures:
 daily-brief status
 ```
 
-Status output is the operational surface for collection, analysis, archive, and delivery health.
+Status output reports setup readiness, today's run state, active paths, system timezone, and the next suggested action. It is a local inspection command: it does not refresh OAuth, call an LLM, collect Sources, or send Discord notifications.
 
 ## Paths and Environment
 
@@ -109,10 +110,8 @@ 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.
 
-Repository checkouts may use a local `.env`; installed usage should normally rely on user configuration and credential commands.
+Model access, Discord delivery, Source choices, and secrets are configured through `config.yaml`, `sources.yaml`, and `auth.json`, not environment variables.
 
 ## Upgrade
 
@@ -123,7 +122,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 +148,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.3",
   "description": "Agent-driven daily brief CLI for manually curated Agent architecture and AI Coding sources.",
   "private": false,
   "type": "module",