@co0ontty/wand 4.89.5 → 4.90.0

package/dist/server.js

@@ -14,7 +14,7 @@ import { AuthService, BROWSER_ADMIN_PRINCIPAL, CONNECTED_APP_PRINCIPAL, principa
 import { ensureCertificates } from "./cert.js";
 import { getDefaultModelForProvider, getProviderDefaultModels, isExecutionMode, resolveConfigDir, writePreferenceToStorage, } from "./config.js";
 import { ModelCatalogService } from "./models.js";
-import { defaultModelGroupSelector } from "./model-groups.js";
+import { fallbackProviderModel, sessionEmployeeFields } from "./session-model.js";
 import { ProcessManager } from "./process-manager.js";
 import { SessionLogger } from "./session-logger.js";
 import { coreHarnessAgentDir, warmCoreHarness } from "./harness-engine.js";
@@ -42,11 +42,14 @@ import { inferProviderFromCommand, isSessionProvider } from "./session-provider.
 import { registerVaultRoutes } from "./server-vault-routes.js";
 import { registerGithubRoutes } from "./server-github-routes.js";
 import { registerTaskRoutes } from "./server-task-routes.js";
+import { taskTitleService } from "./task-title-service.js";
 import { getGithubConnectorStatus } from "./github-connector.js";
 import { registerMissionRoutes } from "./server-mission-routes.js";
 import { Missions } from "./missions.js";
 import { AI_TEAM_CHAT_PREFIX, createAiTeamRunner } from "./ai-team-runner.js";
 import { ConversationService } from "./conversation-service.js";
+import { ScheduledTaskService } from "./scheduled-task-service.js";
+import { registerScheduledTaskRoutes } from "./server-scheduled-task-routes.js";
 import { CONVERSATION_RELAY_PREFIX } from "./conversation-types.js";
 import { forwardConversationRelay, registerConversationRoutes } from "./server-conversation-routes.js";
 import { registerAiTeamRoutes } from "./server-ai-team-routes.js";
@@ -57,10 +60,11 @@ import { UserMemoryService } from "./user-memory.js";
 import { registerUserMemoryRoutes, userMemoryOperationLog } from "./server-user-memory.js";
 import { registerAttentionRoutes } from "./server-attention-routes.js";
 import { refreshProviderCliUpdateState, registerAdminUpdateRoutes, registerPublicUpdateRoutes, ServerUpdateState, } from "./server-update-routes.js";
-import { parseSessionCreationOrigin, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
+import { registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
+import { parseSessionCreationOrigin } from "./session-request.js";
 import { registerWorkspaceRoutes } from "./server-workspace-routes.js";
 import { resolveSessionCwd } from "./session-cwd.js";
-import { resolveWorkspaceIdForNewSession } from "./workspace-binding.js";
+import { backfillSessionWorkspaces, resolveWorkspaceIdForNewSession } from "./workspace-binding.js";
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute, jsonErrorHandler } from "./express-async.js";
 import { checkPackageUpdateAsync, installPackageGloballyAsync, normalizeUpdateChannel, resolveGlobalWandCli, } from "./npm-update-utils.js";
@@ -81,7 +85,7 @@ import { DistributionManager } from "./distribution-manager.js";
 import { isLogBusActive, wandTuiLog } from "./tui/log-bus.js";
 import { EMBEDDED_WEB_ASSETS } from "./web-ui/embedded-assets.js";
 import { renderApp } from "./web-ui/index.js";
-import { getAiTeamsChunk, getPlushAvatarChunk, getScriptAsset, getThemePreloadAsset } from "./web-ui/scripts.js";
+import { getAiTeamsChunk, getBrowserModule, getPlushAvatarChunk, getScriptAsset, getThemePreloadAsset } from "./web-ui/scripts.js";
 import { getStylesAsset } from "./web-ui/styles.js";
 import { WsBroadcastManager } from "./ws-broadcast.js";
 import { TerminalDaemonClient } from "./terminal-daemon-client.js";
@@ -125,7 +129,9 @@ async function checkLatestPackageVersion(channel, forceRefresh = false) {
     if (!forceRefresh && cached && now - cached.timestamp < CACHE_TTL_MS) {
         return cached.info;
     }
-    const info = await checkPackageUpdateAsync(PKG_VERSION, channel);
+    // The immutable running build is also what the UI reports. Shared package metadata may
+    // belong to a different installer; it must not make a local Beta look like an older stable.
+    const info = await checkPackageUpdateAsync(DISPLAY_VERSION, channel);
     if (info.latest) {
         packageUpdateCache.set(channel, { info, timestamp: now });
     }
@@ -325,6 +331,11 @@ export async function startServer(config, configPath, options = {}) {
     const testMode = process.env.WAND_TEST_MODE === "1";
     app.set("trust proxy", "loopback, 172.16.0.0/12");
     const storage = new WandStorage(resolveDatabasePath(configPath));
+    if (!storage.getConfigValue("migration:session-workspaces:v1")) {
+        backfillSessionWorkspaces(storage);
+        storage.setConfigValue("migration:session-workspaces:v1", "done");
+    }
+    const taskTitles = taskTitleService(storage, { config });
     const runtimeConfig = new RuntimeConfigState(config);
     const openRouter = new OpenRouterFreeModelsService(storage, options.openRouterFetch);
     const speechPolisher = new SpeechPolisherService({ config, free: openRouter,
@@ -462,6 +473,8 @@ export async function startServer(config, configPath, options = {}) {
         notifySession: update => notifyConversationSession(update), deleteSession: id => { sessionRegistry.deleteWithProviderHistory(id); } });
     conversations = conversationService;
     conversationService.migrateExistingChats();
+    const scheduledTasks = new ScheduledTaskService({ storage, conversations: conversationService,
+        getSession: id => sessionRegistry.get(id), defaultCwd: () => config.defaultCwd });
     for (const prefix of [CONVERSATION_RELAY_PREFIX, AI_TEAM_CHAT_PREFIX]) {
         structuredSessions.registerRelay(prefix, (sessionId, input) => forwardConversationRelay(conversationService, sessionId, input));
     }
@@ -564,6 +577,18 @@ export async function startServer(config, configPath, options = {}) {
         setAssetCache(req, res, asset.hash, "private");
         res.type("application/javascript").send(asset.content);
     });
+    app.get("/assets/modules/:build/:file", (req, res) => {
+        const content = getBrowserModule(`modules/${req.params.build}/${req.params.file}`);
+        if (content === undefined) {
+            res.setHeader("Cache-Control", "no-store");
+            res.status(404).type("text/plain").send("Browser module not found; reload the page after updating.");
+            return;
+        }
+        // The directory fingerprints the entire immutable module graph. Never
+        // substitute current bytes for a missing older module under its cached URL.
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+        res.type("application/javascript").send(content);
+    });
     app.get("/assets/ai-teams.js", (req, res) => {
         const chunk = getAiTeamsChunk(requestedHash(req));
         setAssetCache(req, res, chunk.hash, "public");
@@ -737,6 +762,7 @@ export async function startServer(config, configPath, options = {}) {
         "/api/session-directories",
         "/api/structured-sessions",
         "/api/conversations",
+        "/api/scheduled-tasks",
         "/api/commands",
         "/api/user-memory",
         "/api/claude-history",
@@ -773,6 +799,7 @@ export async function startServer(config, configPath, options = {}) {
         "/api/validate-path",
         "/api/file-search",
         "/api/local-file",
+        "/api/session-file",
     ], requireFiles);
     app.use("/api/browser-extension", requirePasswordVault);
     app.use("/api/silicon-employees/:employeeId/knowledge", requireSessions);
@@ -871,6 +898,7 @@ export async function startServer(config, configPath, options = {}) {
     });
     registerAttentionRoutes(app, { sessions: sessionRegistry, runner: aiTeams });
     registerConversationRoutes(app, conversationService);
+    registerScheduledTaskRoutes(app, scheduledTasks);
     registerAdminUpdateRoutes(app, {
         storage,
         config,
@@ -971,9 +999,7 @@ export async function startServer(config, configPath, options = {}) {
             const command = provider === "qoder" && rawCommand === "qoder"
                 ? "qodercli"
                 : rawCommand;
-            const effectiveModel = provider
-                ? rawModel || defaultModelGroupSelector(config.modelGroups, provider, getDefaultModelForProvider(config, provider)) || getDefaultModelForProvider(config, provider) || undefined
-                : undefined;
+            const effectiveModel = provider ? rawModel || fallbackProviderModel(config, provider) : undefined;
             const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
             const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
             const sessionCwd = resolveSessionCwd(body.cwd, config.defaultCwd);
@@ -998,9 +1024,7 @@ export async function startServer(config, configPath, options = {}) {
                     rows: reqRows,
                     thinkingEffort: body.thinkingEffort ?? config.defaultThinkingEffort,
                     systemPrompt: body.systemPrompt?.trim() || role?.prompt,
-                    employeeId: role?.id,
-                    employeeName: role?.name,
-                    employeeAvatar: role?.avatar,
+                    ...sessionEmployeeFields(role),
                     workspaceId,
                     workspaceTaskId: body.workspaceTaskId,
                     ...origin,
@@ -1086,13 +1110,16 @@ export async function startServer(config, configPath, options = {}) {
     });
     // Wire process events to WebSocket broadcast
     processes.on("process", (event) => {
+        taskTitles.ingest(event);
         sessionCompletions.ingest(event);
         missions.ingest(event);
         aiTeams.ingest(event);
         wsManager.emitEvent(event);
     });
     structuredSessions.setEventEmitter((event) => {
+        taskTitles.ingest(event);
         conversationService.ingestSessionEvent(event);
+        scheduledTasks.ingestSessionEvent(event);
         sessionCompletions.ingest(event);
         missions.ingest(event);
         aiTeams.ingest(event);
@@ -1184,8 +1211,9 @@ export async function startServer(config, configPath, options = {}) {
     let bindAddr = config.host === "0.0.0.0" ? "0.0.0.0" : config.host;
     const collectedUrls = [];
     await new Promise((resolve, reject) => {
-        const cleanupFailedListen = () => {
+        const cleanupFailedListen = async () => {
             shuttingDown = true;
+            await scheduledTasks.dispose();
             decisions.dispose();
             openRouter.dispose();
             try {
@@ -1200,7 +1228,9 @@ export async function startServer(config, configPath, options = {}) {
                 structuredSessions.dispose();
             }
             catch { /* noop */ }
-            aiTeams.dispose();
+            taskTitles.dispose();
+            modelCatalog.dispose();
+            await aiTeams.dispose();
             try {
                 structuredHosts.rustClient?.disconnect();
             }
@@ -1229,12 +1259,9 @@ export async function startServer(config, configPath, options = {}) {
         };
         const onListenError = (err) => {
             server.off("error", onListenError);
-            cleanupFailedListen();
-            if (err.code === "EADDRINUSE") {
-                reject(new PortInUseError(config.port, config.host));
-                return;
-            }
-            reject(err);
+            void cleanupFailedListen().then(() => {
+                reject(err.code === "EADDRINUSE" ? new PortInUseError(config.port, config.host) : err);
+            }, reject);
         };
         server.once("error", onListenError);
         server.listen(config.port, config.host, () => {
@@ -1261,6 +1288,8 @@ export async function startServer(config, configPath, options = {}) {
     const updateChecksEnabled = !testMode && process.env.WAND_DISABLE_UPDATE_CHECK !== "1";
     if (!testMode)
         userMemory.start();
+    if (!testMode)
+        scheduledTasks.start();
     // Start configured background sessions after the server is already reachable.
     if (!testMode) {
         void processes.runStartupCommands().catch((error) => {
@@ -1309,6 +1338,8 @@ export async function startServer(config, configPath, options = {}) {
         catch { /* 扫描结果已经返回给保存请求，通知失败不回滚 */ }
         return result;
     };
+    if (!testMode)
+        taskTitles.refresh();
     let retentionTimer = null;
     if (!testMode) {
         retentionTimer = startRetentionTimer(retentionDeps, 60 * 60 * 1000, sweepRetention);
@@ -1461,6 +1492,10 @@ export async function startServer(config, configPath, options = {}) {
             return closePromise;
         closePromise = (async () => {
             shuttingDown = true;
+            taskTitles.dispose();
+            modelCatalog.dispose();
+            const teamShutdown = aiTeams.dispose();
+            await scheduledTasks.dispose();
             await daemonMaintenance.stop();
             decisions.dispose();
             openRouter.dispose();
@@ -1521,7 +1556,7 @@ export async function startServer(config, configPath, options = {}) {
                 structuredSessions.dispose();
             }
             catch { /* best-effort shutdown */ }
-            aiTeams.dispose();
+            await teamShutdown;
             try {
                 structuredHosts.rustClient?.disconnect();
             }

package/dist/session-model.d.ts

@@ -0,0 +1,15 @@
+import type { SessionProvider, WandConfig } from "./types.js";
+/** The repeated `group selector || provider default` tail. Callers keep their own explicit-model precedence. */
+export declare function fallbackProviderModel(config: WandConfig, provider: SessionProvider): string | undefined;
+/** Employee and conversation creates treat blank and `default` as the configured fallback. */
+export declare function resolveExplicitOrFallbackModel(config: WandConfig, provider: SessionProvider, explicit: string | null | undefined): string | undefined;
+/** Identity stamped onto a new session. Execution stays with the caller's own start/createSession. */
+export declare function sessionEmployeeFields(role: {
+    id?: string;
+    name?: string;
+    avatar?: string;
+} | null | undefined): {
+    employeeId?: string;
+    employeeName?: string;
+    employeeAvatar?: string;
+};

package/dist/session-model.js

@@ -0,0 +1,23 @@
+import { getDefaultModelForProvider } from "./config.js";
+import { defaultModelGroupSelector } from "./model-groups.js";
+/** The repeated `group selector || provider default` tail. Callers keep their own explicit-model precedence. */
+export function fallbackProviderModel(config, provider) {
+    return defaultModelGroupSelector(config.modelGroups, provider, getDefaultModelForProvider(config, provider))
+        || getDefaultModelForProvider(config, provider)
+        || undefined;
+}
+/** Employee and conversation creates treat blank and `default` as the configured fallback. */
+export function resolveExplicitOrFallbackModel(config, provider, explicit) {
+    const model = explicit?.trim() ?? "";
+    if (model && model !== "default")
+        return model;
+    return fallbackProviderModel(config, provider);
+}
+/** Identity stamped onto a new session. Execution stays with the caller's own start/createSession. */
+export function sessionEmployeeFields(role) {
+    return {
+        employeeId: role?.id,
+        employeeName: role?.name,
+        employeeAvatar: role?.avatar,
+    };
+}

package/dist/session-registry.d.ts

@@ -1,11 +1,13 @@
 import type { ProcessManager } from "./process-manager.js";
-import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { WandStorage } from "./storage.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { ExecutionMode, SessionSnapshot } from "./types.js";
 export type SessionOwner = "structured" | "pty" | "storage";
 export type ProviderHistoryDeleter = Pick<ProcessManager, "deleteClaudeHistoryFiles" | "deleteCodexHistoryFiles" | "deleteOpenCodeHistorySessions" | "deleteQoderHistoryFiles" | "deletePiHistoryFiles" | "deleteGrokHistoryFiles" | "deleteGeminiHistoryFiles">;
 export declare function deleteProviderNativeHistory(deleter: ProviderHistoryDeleter, provider: string, providerSessionId: string, cwd: string): void;
 type HiddenSessionStore = Pick<WandStorage, "getConfigValue" | "setConfigValue">;
+/** The owner deletes the managed session first; native history/tombstones have one implementation. */
+export declare function deleteOwnedSessionWithHistory(remove: () => SessionSnapshot | null, deleter: ProviderHistoryDeleter, storage: HiddenSessionStore): SessionSnapshot | null;
 /** 读取 `hidden_claude_session_ids`；坏数据 / 空值按空集合处理，不抛错。 */
 export declare function readHiddenSessionIds(storage: Pick<HiddenSessionStore, "getConfigValue">): Set<string>;
 /** 写回 `hidden_claude_session_ids`（保持既有的 JSON 数组格式）。 */
@@ -26,6 +28,8 @@ export declare class SessionRegistry {
     ownerOf(id: string): SessionOwner | null;
     get(id: string): SessionSnapshot | null;
     getLatest(id: string): SessionSnapshot | null;
+    /** Runtime facts and membership only; list/policy reads must not hydrate transcripts. */
+    getSlim(id: string): SessionSnapshot | null;
     listSlim(): SessionSnapshot[];
     /** Membership belongs to storage; both runners only refresh their live projection. */
     refreshSessionWorkspace(id: string): void;

package/dist/session-registry.js

@@ -31,6 +31,20 @@ export function deleteProviderNativeHistory(deleter, provider, providerSessionId
             break;
     }
 }
+/** The owner deletes the managed session first; native history/tombstones have one implementation. */
+export function deleteOwnedSessionWithHistory(remove, deleter, storage) {
+    const snapshot = remove();
+    const providerSessionId = snapshot?.claudeSessionId?.trim();
+    if (!snapshot || !providerSessionId)
+        return snapshot;
+    const provider = snapshot.provider
+        ?? snapshot.structuredState?.provider
+        ?? inferProviderFromCommand(snapshot.command)
+        ?? "claude";
+    deleteProviderNativeHistory(deleter, provider, providerSessionId, snapshot.cwd);
+    addHiddenSessionIds(storage, [providerSessionId]);
+    return snapshot;
+}
 /** 读取 `hidden_claude_session_ids`；坏数据 / 空值按空集合处理，不抛错。 */
 export function readHiddenSessionIds(storage) {
     const raw = storage.getConfigValue("hidden_claude_session_ids");
@@ -103,6 +117,11 @@ export class SessionRegistry {
     getLatest(id) {
         return this.get(id);
     }
+    /** Runtime facts and membership only; list/policy reads must not hydrate transcripts. */
+    getSlim(id) {
+        const snapshot = this.structured.getSlim(id) ?? this.processes.getOwnedSlim(id) ?? this.storage.getSessionSlim(id);
+        return snapshot ? { ...snapshot, ...this.storage.getSessionWorkspace(id), ...this.storage.getSessionCompletion(id) } : null;
+    }
     listSlim() {
         const byId = new Map();
         for (const snapshot of this.structured.listSlim())
@@ -242,17 +261,7 @@ export class SessionRegistry {
         return snapshot;
     }
     deleteWithProviderHistory(id) {
-        const snapshot = this.delete(id);
-        const providerSessionId = snapshot?.claudeSessionId?.trim();
-        if (!snapshot || !providerSessionId)
-            return snapshot;
-        const provider = snapshot.provider
-            ?? snapshot.structuredState?.provider
-            ?? inferProviderFromCommand(snapshot.command)
-            ?? "claude";
-        deleteProviderNativeHistory(this.processes, provider, providerSessionId, snapshot.cwd);
-        addHiddenSessionIds(this.storage, [providerSessionId]);
-        return snapshot;
+        return deleteOwnedSessionWithHistory(() => this.delete(id), this.processes, this.storage);
     }
     updateStored(id, update) {
         const current = this.storage.getSession(id);

package/dist/session-request.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionMode, SessionSource } from "./types.js";
+export declare function parseExecutionMode(value: unknown, fallback: ExecutionMode): ExecutionMode;
+export declare function parseSessionCreationOrigin(body: {
+    sessionSource?: unknown;
+    automationId?: unknown;
+} | null | undefined): {
+    sessionSource: SessionSource;
+    automationId?: string;
+};

package/dist/session-request.js

@@ -0,0 +1,27 @@
+import { isExecutionMode } from "./config.js";
+export function parseExecutionMode(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!isExecutionMode(value)) {
+        throw new Error(`无效执行模式: ${String(value)}`);
+    }
+    return value;
+}
+export function parseSessionCreationOrigin(body) {
+    const rawSource = body?.sessionSource;
+    if (rawSource !== undefined && rawSource !== "interactive" && rawSource !== "automation" && rawSource !== "startup") {
+        throw new Error("sessionSource 必须是 interactive、automation 或 startup。");
+    }
+    const rawAutomationId = body?.automationId;
+    if (rawAutomationId !== undefined && typeof rawAutomationId !== "string") {
+        throw new Error("automationId 必须是非空字符串。");
+    }
+    const automationId = rawAutomationId?.trim();
+    if (rawAutomationId !== undefined && !automationId) {
+        throw new Error("automationId 必须是非空字符串。");
+    }
+    return {
+        sessionSource: rawSource ?? "interactive",
+        ...(automationId ? { automationId } : {}),
+    };
+}

package/dist/session-topic.d.ts

@@ -1,4 +1,4 @@
-import { type QuickCommitAiOptions } from "./git-quick-commit.js";
+import { type QuickCommitAiOptions } from "./ai-text-runner.js";
 import type { ConversationTurn } from "./types.js";
 /**
  * PTY 底部输入框整段提交（shortcutKey=enter_text）会总结标题。

package/dist/session-topic.js

@@ -1,4 +1,4 @@
-import { callConfiguredAiText } from "./git-quick-commit.js";
+import { callConfiguredAiText } from "./ai-text-runner.js";
 import { skipAnsiSequence } from "./pty-text-utils.js";
 import { clipAtWordBoundary } from "./text-utils.js";
 const MAX_PROMPT_LENGTH = 12_000;

package/dist/session-transport.d.ts

@@ -26,7 +26,9 @@ export interface SessionDetailDTO extends SessionBaseDTO {
 }
 /** Resolve every client-visible title on the server so all clients show the same value. */
 export declare function resolveSessionDisplayTitle(snapshot: SessionSnapshot, blockedTitles?: readonly string[]): string;
-export declare function toSessionListItemDTO(snapshot: SessionSnapshot): SessionListItemDTO;
+export declare function toSessionListItemDTO(snapshot: SessionSnapshot, options?: {
+    avatar?: "full" | "compact";
+}): SessionListItemDTO;
 export interface SessionDetailDTOOptions {
     output?: string;
     messages?: ConversationTurn[];

package/dist/session-transport.js

@@ -1,3 +1,4 @@
+import { compactTransportAvatar } from "./fixed-employee-avatar.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
 import { normalizeTurnAnchors } from "./structured-provider-common.js";
 import { collectSessionTopicBlocklist, shouldAcceptGeneratedSessionTitle, summarizeSessionTitleFromInput, } from "./session-topic.js";
@@ -21,15 +22,20 @@ export function resolveSessionDisplayTitle(snapshot, blockedTitles = []) {
         return directory;
     return "会话";
 }
-/** Explicit allow-list separating the server's session object from its wire DTO. */
-function sessionBase(snapshot) {
+/**
+ * Explicit allow-list separating the server's session object from its wire DTO.
+ * queuedMessages, piSettings and worktreeMergeInfo stay on this DTO: Web loads
+ * GET /api/sessions as the live session, and iOS decodes /api/session-list into
+ * the same snapshot. Nested task and workspace cards already use a slimmer summary.
+ */
+function sessionBase(snapshot, avatarMode = "full") {
     return {
         id: snapshot.id,
         sessionSource: snapshot.sessionSource,
         automationId: snapshot.automationId,
         employeeId: snapshot.employeeId,
         employeeName: snapshot.employeeName,
-        employeeAvatar: snapshot.employeeAvatar,
+        employeeAvatar: avatarMode === "compact" ? compactTransportAvatar(snapshot.employeeAvatar) : snapshot.employeeAvatar,
         employeeCandidateIndex: snapshot.employeeCandidateIndex,
         sessionKind: snapshot.sessionKind,
         provider: snapshot.provider,
@@ -86,8 +92,8 @@ function sessionBase(snapshot) {
         ptyRows: snapshot.ptyRows,
     };
 }
-export function toSessionListItemDTO(snapshot) {
-    return { ...sessionBase(snapshot), output: "" };
+export function toSessionListItemDTO(snapshot, options = {}) {
+    return { ...sessionBase(snapshot, options.avatar ?? "full"), output: "" };
 }
 export function toSessionDetailDTO(snapshot, options = {}) {
     const rawOutput = options.output ?? snapshot.output;

package/dist/silicon-employee-draft.d.ts

@@ -1,4 +1,4 @@
-import { type QuickCommitAiOptions } from "./git-quick-commit.js";
+import { type QuickCommitAiOptions } from "./ai-text-runner.js";
 import { type SiliconEmployeeDraft } from "./ai-team-types.js";
 import type { AiTextRequest } from "./types.js";
 import type { WandTaskAgent } from "./task-types.js";
@@ -41,7 +41,7 @@ export declare function parseSiliconEmployeeDraft(raw: string, options?: {
 }): SiliconEmployeeDraft;
 /** HR / 客户端已给出完整结构化草稿时走同一校验，不再调用模型。 */
 export declare function validateStructuredEmployeeDraft(input: unknown, options?: Omit<EmployeeDraftNormalizeOptions, "strict">): SiliconEmployeeDraft;
-/** 规则走系统提示，用户的期望走用户消息；一次性调用沿用系统 AI 通道。 */
+/** 招聘格式规则走系统提示，岗位需求走用户消息；执行通道由 HR 配置提供。 */
 export declare function buildEmployeeDraftPrompt(expectation: string, providers: SessionProvider[], existingNames?: string[]): AiTextRequest;
 /** 按自然语言期望生成员工配置；调用方负责随后落库。 */
 export declare function generateSiliconEmployeeDraft(expectation: string, ai?: QuickCommitAiOptions, options?: {

package/dist/silicon-employee-draft.js

@@ -1,4 +1,4 @@
-import { callConfiguredAiText } from "./git-quick-commit.js";
+import { callConfiguredAiText } from "./ai-text-runner.js";
 import { employeeCliAvailable } from "./silicon-employee-dispatch.js";
 import { SESSION_PROVIDERS, isSessionProvider } from "./session-provider.js";
 import { isThinkingEffort } from "./structured-provider-common.js";
@@ -186,11 +186,11 @@ export function validateStructuredEmployeeDraft(input, options = {}) {
     }
     return normalizeSiliconEmployeeDraft(input, { ...options, strict: true });
 }
-/** 规则走系统提示，用户的期望走用户消息；一次性调用沿用系统 AI 通道。 */
+/** 招聘格式规则走系统提示，岗位需求走用户消息；执行通道由 HR 配置提供。 */
 export function buildEmployeeDraftPrompt(expectation, providers, existingNames = []) {
     const list = providers.length ? providers : [...SESSION_PROVIDERS];
     const lines = [
-        "你正在帮用户创建一位「硅基员工」：一个长期负责某类工作的 AI 角色，之后会以结构化会话执行任务。",
+        "你正在为用户招聘一位「硅基员工」：一个长期负责某类工作的 AI 角色，之后会以结构化会话执行任务。这里只拟定人选资料，不办理入职。",
         "根据用户对这位员工的期望，设计一份配置，只输出一个 JSON 对象（不要 Markdown 代码块，不要任何解释）：",
         '{"name":"员工名字","duty":"一句话职责","prompt":"角色设定","provider":"执行工具"}',
         "",

package/dist/socket-probe.d.ts

@@ -0,0 +1,2 @@
+/** Read-only liveness probe; no authentication or daemon replacement. */
+export declare function probeUnixSocket(socketPath: string): Promise<boolean>;

package/dist/socket-probe.js

@@ -0,0 +1,20 @@
+import net from "node:net";
+/** Read-only liveness probe; no authentication or daemon replacement. */
+export function probeUnixSocket(socketPath) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(socketPath);
+        let settled = false;
+        const finish = (alive) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(alive);
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+        const timer = setTimeout(() => finish(false), 300);
+        timer.unref?.();
+    });
+}

package/dist/storage-schedules.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { ScheduledTask, ScheduledTaskRun } from "./scheduled-task-types.js";
+/** Same SQLite connection and transaction owner as WandStorage; no separate lifecycle. */
+export declare class ScheduledTaskRepository {
+    private db;
+    private transaction;
+    constructor(db: DatabaseSync, transaction: <T>(action: () => T) => T);
+    listScheduledTasks(includeCancelled?: boolean): ScheduledTask[];
+    listDueScheduledTasks(now: string): ScheduledTask[];
+    getScheduledTask(id: string): ScheduledTask | null;
+    createScheduledTask(task: ScheduledTask): boolean;
+    updateScheduledTask(task: ScheduledTask, expectedRevision: number): boolean;
+    /** Claim and advance together before any execution can escape the process. */
+    claimScheduledTaskRun(task: ScheduledTask, run: ScheduledTaskRun, nextRunAt: string | null): boolean;
+    saveScheduledTaskRun(run: ScheduledTaskRun): void;
+    getScheduledTaskRun(id: string): ScheduledTaskRun | null;
+    listOpenScheduledTaskRuns(taskId?: string): ScheduledTaskRun[];
+    getOpenScheduledTaskRunsForSession(sessionId: string): ScheduledTaskRun[];
+    listScheduledTaskRuns(taskId?: string, limit?: number): ScheduledTaskRun[];
+}

package/dist/storage-schedules.js

@@ -0,0 +1,78 @@
+/** Same SQLite connection and transaction owner as WandStorage; no separate lifecycle. */
+export class ScheduledTaskRepository {
+    db;
+    transaction;
+    constructor(db, transaction) {
+        this.db = db;
+        this.transaction = transaction;
+    }
+    listScheduledTasks(includeCancelled = false) {
+        const rows = this.db.prepare(`SELECT task_json FROM scheduled_tasks ${includeCancelled ? "" : "WHERE cancelled_at IS NULL"} ORDER BY rowid DESC`)
+            .all();
+        return rows.map(row => JSON.parse(row.task_json));
+    }
+    listDueScheduledTasks(now) {
+        const rows = this.db.prepare(`SELECT task_json FROM scheduled_tasks
+      WHERE enabled = 1 AND cancelled_at IS NULL AND next_run_at <= ? ORDER BY rowid DESC`)
+            .all(now);
+        return rows.map(row => JSON.parse(row.task_json));
+    }
+    getScheduledTask(id) {
+        const row = this.db.prepare("SELECT task_json FROM scheduled_tasks WHERE id = ?").get(id);
+        return row ? JSON.parse(row.task_json) : null;
+    }
+    createScheduledTask(task) {
+        return this.db.prepare("INSERT OR IGNORE INTO scheduled_tasks(id, enabled, next_run_at, revision, cancelled_at, task_json) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(task.id, Number(task.enabled), task.nextRunAt, task.revision, task.cancelledAt, JSON.stringify(task)).changes === 1;
+    }
+    updateScheduledTask(task, expectedRevision) {
+        return this.db.prepare(`UPDATE scheduled_tasks SET enabled = ?, next_run_at = ?, revision = ?, cancelled_at = ?, task_json = ?
+      WHERE id = ? AND revision = ?`).run(Number(task.enabled), task.nextRunAt, task.revision, task.cancelledAt, JSON.stringify(task), task.id, expectedRevision).changes === 1;
+    }
+    /** Claim and advance together before any execution can escape the process. */
+    claimScheduledTaskRun(task, run, nextRunAt) {
+        return this.transaction(() => {
+            const current = this.getScheduledTask(task.id);
+            if (!current?.enabled || current.cancelledAt || current.revision !== task.revision
+                || current.nextRunAt !== run.scheduledAt || current.nextRunAt !== task.nextRunAt)
+                return false;
+            const result = this.db.prepare("INSERT OR IGNORE INTO scheduled_task_runs(id, task_id, scheduled_at, run_json) VALUES (?, ?, ?, ?)")
+                .run(run.id, run.taskId, run.scheduledAt, JSON.stringify(run));
+            if (result.changes !== 1)
+                return false;
+            const advanced = { ...current, nextRunAt, enabled: nextRunAt !== null,
+                revision: current.revision + 1, updatedAt: run.claimedAt };
+            this.db.prepare("UPDATE scheduled_tasks SET enabled = ?, next_run_at = ?, revision = ?, task_json = ? WHERE id = ?")
+                .run(Number(advanced.enabled), nextRunAt, advanced.revision, JSON.stringify(advanced), task.id);
+            return true;
+        });
+    }
+    saveScheduledTaskRun(run) {
+        this.db.prepare("UPDATE scheduled_task_runs SET run_json = ? WHERE id = ? AND task_id = ?")
+            .run(JSON.stringify(run), run.id, run.taskId);
+    }
+    getScheduledTaskRun(id) {
+        const row = this.db.prepare("SELECT run_json FROM scheduled_task_runs WHERE id = ?").get(id);
+        return row ? JSON.parse(row.run_json) : null;
+    }
+    listOpenScheduledTaskRuns(taskId) {
+        const query = `SELECT run_json FROM scheduled_task_runs WHERE json_extract(run_json, '$.executionFinishedAt') IS NULL
+      AND json_extract(run_json, '$.state') IN ('claimed', 'accepted', 'unknown')`;
+        const rows = (taskId ? this.db.prepare(`${query} AND task_id = ? ORDER BY scheduled_at`).all(taskId)
+            : this.db.prepare(`${query} ORDER BY scheduled_at`).all());
+        return rows.map(row => JSON.parse(row.run_json));
+    }
+    getOpenScheduledTaskRunsForSession(sessionId) {
+        const rows = this.db.prepare(`SELECT run_json FROM scheduled_task_runs WHERE json_extract(run_json, '$.receipt.sessionId') = ?
+      AND json_extract(run_json, '$.executionFinishedAt') IS NULL`)
+            .all(sessionId);
+        return rows.map(row => JSON.parse(row.run_json));
+    }
+    listScheduledTaskRuns(taskId, limit = 50) {
+        const bounded = Math.max(1, Math.min(500, Number.isFinite(limit) ? Math.floor(limit) : 50));
+        const rows = (taskId
+            ? this.db.prepare("SELECT run_json FROM scheduled_task_runs WHERE task_id = ? ORDER BY scheduled_at DESC LIMIT ?").all(taskId, bounded)
+            : this.db.prepare("SELECT run_json FROM scheduled_task_runs ORDER BY scheduled_at DESC LIMIT ?").all(bounded));
+        return rows.map(row => JSON.parse(row.run_json));
+    }
+}

package/dist/storage-schema.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseSync } from "node:sqlite";
+export declare function initializeStorageSchema(db: DatabaseSync): void;
+export declare function ensureDatabaseFile(dbPath: string): boolean;