@longrun-ai/kernel 1.8.5

package/LICENSE

@@ -0,0 +1 @@
+See ../../LICENSE

package/README.md

@@ -0,0 +1,3 @@
+# @longrun-ai/kernel
+
+Public Dominds kernel contracts for app install-json parsing, app host/runtime types, and shared team-manual helpers.

package/dist/app-host-contract.d.ts

@@ -0,0 +1,87 @@
+import type { DomindsAppFrontendJson, DomindsAppHostReminderUpdateResult, DomindsAppHostToolHandler, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from './app-json';
+import type { LanguageCode } from './types/language';
+export type ChatMessage = Readonly<Record<string, unknown>>;
+export type DomindsAppRunControlContext = Readonly<{
+    dialog: Readonly<{
+        selfId: string;
+        rootId: string;
+    }>;
+    agentId: string;
+    taskDocPath: string;
+    genIterNo: number;
+    prompt?: Readonly<{
+        content: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode: LanguageCode;
+        origin?: 'user' | 'diligence_push' | 'runtime';
+    }>;
+    source: 'drive_dlg_by_user_msg' | 'drive_dialog_by_user_answer';
+    input: Readonly<Record<string, unknown>>;
+    q4h?: Readonly<{
+        questionId: string;
+        continuationType: 'answer' | 'followup' | 'retry' | 'new_message';
+    }>;
+}>;
+export type DomindsAppRunControlResult = Readonly<{
+    kind: 'continue';
+} | {
+    kind: 'reject';
+    errorText: string;
+}>;
+export type DomindsAppRunControlHandler = (ctx: DomindsAppRunControlContext) => Promise<DomindsAppRunControlResult>;
+export type DomindsAppReminderOwnerApplyContext = Readonly<{
+    dialogId: string;
+    ownedReminders: ReadonlyArray<DomindsAppReminderState>;
+}>;
+export type DomindsAppReminderOwnerUpdateContext = Readonly<{
+    dialogId: string;
+    reminder: DomindsAppReminderState;
+}>;
+export type DomindsAppReminderOwnerRenderContext = Readonly<{
+    dialogId: string;
+    reminder: DomindsAppReminderState;
+    reminderNo: number;
+    workLanguage: LanguageCode;
+}>;
+export type DomindsAppDynamicToolsetsContext = Readonly<{
+    memberId: string;
+    taskDocPath: string;
+    dialogId?: string;
+    rootDialogId?: string;
+    agentId?: string;
+    sessionSlug?: string;
+}>;
+export type DomindsAppReminderOwnerHandler = Readonly<{
+    apply: (request: DomindsAppReminderApplyRequest, ctx: DomindsAppReminderOwnerApplyContext) => Promise<DomindsAppReminderApplyResult>;
+    updateReminder: (ctx: DomindsAppReminderOwnerUpdateContext) => Promise<DomindsAppHostReminderUpdateResult>;
+    renderReminder: (ctx: DomindsAppReminderOwnerRenderContext) => Promise<ChatMessage>;
+}>;
+export type DomindsAppDynamicToolsetsHandler = (ctx: DomindsAppDynamicToolsetsContext) => Promise<readonly string[]>;
+export type DomindsAppHostStartResult = Readonly<{
+    port: number;
+    baseUrl: string;
+    wsUrl: string | null;
+}>;
+export type DomindsAppHostInstance = Readonly<{
+    tools: Readonly<Record<string, DomindsAppHostToolHandler>>;
+    runControls?: Readonly<Record<string, DomindsAppRunControlHandler>>;
+    reminderOwners?: Readonly<Record<string, DomindsAppReminderOwnerHandler>>;
+    dynamicToolsets?: DomindsAppDynamicToolsetsHandler;
+    start?: (params: Readonly<{
+        runtimePort: number | null;
+        frontend?: DomindsAppFrontendJson;
+    }>) => Promise<DomindsAppHostStartResult>;
+    shutdown?: () => Promise<void>;
+}>;
+export type CreateDomindsAppFn = (ctx: Readonly<{
+    appId: string;
+    rtwsRootAbs: string;
+    rtwsAppDirAbs: string;
+    packageRootAbs: string;
+    kernel: Readonly<{
+        host: string;
+        port: number;
+    }>;
+    log: (level: 'info' | 'warn' | 'error', msg: string, data?: Readonly<Record<string, unknown>>) => void;
+}>) => DomindsAppHostInstance | Promise<DomindsAppHostInstance>;

package/dist/app-host-contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app-json.d.ts

@@ -0,0 +1,139 @@
+import type { I18nText } from './types/i18n';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type JsonArray = JsonValue[];
+export type ToolArguments = JsonObject;
+export type JsonSchema = Record<string, unknown>;
+export type ToolCallOutput = string | {
+    content: string;
+    contentItems?: ReadonlyArray<unknown>;
+};
+export interface ReminderUpdateResult {
+    treatment: 'drop' | 'keep' | 'update';
+    updatedContent?: string;
+    updatedMeta?: JsonValue;
+}
+export type DomindsAppJsonSchemaVersion = 1;
+export type DomindsAppToolJson = Readonly<{
+    name: string;
+    description?: string;
+    descriptionI18n?: I18nText;
+    parameters: JsonSchema;
+}>;
+export type DomindsAppToolsetJson = Readonly<{
+    id: string;
+    descriptionI18n?: I18nText;
+    tools: ReadonlyArray<DomindsAppToolJson>;
+}>;
+export type DomindsAppDialogRunControlJson = Readonly<{
+    id: string;
+    descriptionI18n?: I18nText;
+}>;
+export type DomindsAppReminderOwnerJson = Readonly<{
+    ref: string;
+    managedByTool?: string;
+    updateExample?: string;
+}>;
+export type DomindsAppContributesJson = Readonly<{
+    teammatesYamlRelPath?: string;
+    toolsets?: ReadonlyArray<DomindsAppToolsetJson>;
+    dialogRunControls?: ReadonlyArray<DomindsAppDialogRunControlJson>;
+    reminderOwners?: ReadonlyArray<DomindsAppReminderOwnerJson>;
+}>;
+export type DomindsAppHostEntryJson = Readonly<{
+    kind: 'node_module';
+    moduleRelPath: string;
+    exportName: string;
+}>;
+export type DomindsAppFrontendJson = Readonly<{
+    kind: 'http';
+    defaultPort?: number;
+    basePath?: string;
+    wsPath?: string;
+}>;
+export type DomindsAppInstallJsonV1 = Readonly<{
+    schemaVersion: DomindsAppJsonSchemaVersion;
+    appId: string;
+    displayName?: string;
+    package: Readonly<{
+        name: string;
+        version: string | null;
+        rootAbs: string;
+    }>;
+    host: DomindsAppHostEntryJson;
+    frontend?: DomindsAppFrontendJson;
+    contributes?: DomindsAppContributesJson;
+}>;
+export declare function parseDomindsAppInstallJson(v: unknown): {
+    ok: true;
+    json: DomindsAppInstallJsonV1;
+} | {
+    ok: false;
+    errorText: string;
+};
+export type DomindsAppHostToolContext = Readonly<{
+    dialogId: string;
+    rootDialogId: string;
+    agentId: string;
+    taskDocPath: string;
+    sessionSlug?: string;
+    callerId: string;
+}>;
+export type DomindsAppDialogTargetRef = Readonly<{
+    dialogId: string;
+} | {
+    rootDialogId?: string;
+    agentId: string;
+    sessionSlug?: string;
+}>;
+export type DomindsAppDialogInfo = Readonly<{
+    dialogId: string;
+    rootDialogId: string;
+    agentId: string;
+    sessionSlug?: string;
+}>;
+export type DomindsAppReminderState = Readonly<{
+    content: string;
+    meta?: JsonValue;
+    echoback?: boolean;
+}>;
+export type DomindsAppReminderApplyRequest = Readonly<{
+    kind: 'upsert';
+    ownerRef: string;
+    content: string;
+    meta?: JsonValue;
+    position?: number;
+    echoback?: boolean;
+} | {
+    kind: 'delete';
+    ownerRef: string;
+    meta?: JsonValue;
+}>;
+export type DomindsAppReminderApplyResult = Readonly<{
+    treatment: 'noop';
+} | {
+    treatment: 'add';
+    reminder: DomindsAppReminderState;
+    position?: number;
+} | {
+    treatment: 'update';
+    ownedIndex: number;
+    reminder: DomindsAppReminderState;
+} | {
+    treatment: 'delete';
+    ownedIndex: number;
+}>;
+export type DomindsAppDialogReminderRequestBatch = Readonly<{
+    target: DomindsAppDialogTargetRef;
+    reminderRequests: ReadonlyArray<DomindsAppReminderApplyRequest>;
+}>;
+export type DomindsAppHostToolResult = Readonly<{
+    output: ToolCallOutput;
+    reminderRequests?: ReadonlyArray<DomindsAppReminderApplyRequest>;
+    dialogReminderRequests?: ReadonlyArray<DomindsAppDialogReminderRequestBatch>;
+}>;
+export type DomindsAppHostToolHandler = (args: ToolArguments, ctx: DomindsAppHostToolContext) => Promise<ToolCallOutput | DomindsAppHostToolResult>;
+export type DomindsAppHostReminderUpdateResult = ReminderUpdateResult;

package/dist/app-json.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDomindsAppInstallJson = parseDomindsAppInstallJson;
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function asString(v) {
+    return typeof v === 'string' ? v : null;
+}
+function asNullableString(v) {
+    if (v === null)
+        return null;
+    return typeof v === 'string' ? v : null;
+}
+function isI18nText(v) {
+    return isRecord(v) && typeof v['zh'] === 'string' && typeof v['en'] === 'string';
+}
+function isJsonSchema(v) {
+    return isRecord(v);
+}
+function parseToolJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const name = asString(v['name']);
+    if (!name || name.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.name: required` };
+    const description = asString(v['description']) ?? undefined;
+    const descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    const parameters = v['parameters'];
+    if (!isJsonSchema(parameters)) {
+        return { ok: false, errorText: `Invalid ${at}.parameters: expected JSON schema object` };
+    }
+    return {
+        ok: true,
+        tool: {
+            name,
+            description,
+            descriptionI18n: descriptionI18n,
+            parameters,
+        },
+    };
+}
+function parseToolsetJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const id = asString(v['id']);
+    if (!id || id.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.id: required` };
+    const descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    const toolsRaw = v['tools'];
+    if (!Array.isArray(toolsRaw))
+        return { ok: false, errorText: `Invalid ${at}.tools: expected array` };
+    const tools = [];
+    for (let i = 0; i < toolsRaw.length; i += 1) {
+        const parsed = parseToolJson(toolsRaw[i], `${at}.tools[${i}]`);
+        if (!parsed.ok)
+            return parsed;
+        tools.push(parsed.tool);
+    }
+    return {
+        ok: true,
+        toolset: {
+            id,
+            descriptionI18n: descriptionI18n,
+            tools,
+        },
+    };
+}
+function parseDialogRunControlJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const id = asString(v['id']);
+    if (!id || id.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.id: required` };
+    const descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    return {
+        ok: true,
+        control: {
+            id,
+            descriptionI18n: descriptionI18n,
+        },
+    };
+}
+function parseReminderOwnerJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const ref = asString(v['ref']);
+    if (!ref || ref.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.ref: required` };
+    const managedByTool = asString(v['managedByTool']) ?? undefined;
+    const updateExample = asString(v['updateExample']) ?? undefined;
+    return {
+        ok: true,
+        owner: { ref, managedByTool, updateExample },
+    };
+}
+function parseDomindsAppInstallJson(v) {
+    if (!isRecord(v)) {
+        return { ok: false, errorText: 'Invalid app --dominds-app output: expected object' };
+    }
+    const schemaVersion = v['schemaVersion'];
+    if (schemaVersion !== 1) {
+        return { ok: false, errorText: `Unsupported app json schemaVersion: ${String(schemaVersion)}` };
+    }
+    const appId = asString(v['appId']);
+    if (!appId || appId.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: appId required' };
+    const displayName = asString(v['displayName']) ?? undefined;
+    const pkg = v['package'];
+    if (!isRecord(pkg))
+        return { ok: false, errorText: 'Invalid app json: package must be an object' };
+    const packageName = asString(pkg['name']);
+    const packageVersion = asNullableString(pkg['version']);
+    const rootAbs = asString(pkg['rootAbs']);
+    if (!packageName || packageName.trim() === '') {
+        return { ok: false, errorText: 'Invalid app json: package.name required' };
+    }
+    if (packageVersion !== null && (!packageVersion || packageVersion.trim() === '')) {
+        return { ok: false, errorText: 'Invalid app json: package.version must be string|null' };
+    }
+    if (!rootAbs || rootAbs.trim() === '') {
+        return { ok: false, errorText: 'Invalid app json: package.rootAbs required' };
+    }
+    const host = v['host'];
+    if (!isRecord(host))
+        return { ok: false, errorText: 'Invalid app json: host must be an object' };
+    const hostKind = asString(host['kind']);
+    if (hostKind !== 'node_module') {
+        return { ok: false, errorText: "Invalid app json: host.kind must be 'node_module'" };
+    }
+    const moduleRelPath = asString(host['moduleRelPath']);
+    const exportName = asString(host['exportName']);
+    if (!moduleRelPath || moduleRelPath.trim() === '') {
+        return { ok: false, errorText: 'Invalid app json: host.moduleRelPath required' };
+    }
+    if (!exportName || exportName.trim() === '') {
+        return { ok: false, errorText: 'Invalid app json: host.exportName required' };
+    }
+    const frontendRaw = v['frontend'];
+    let frontend;
+    if (frontendRaw !== undefined) {
+        if (!isRecord(frontendRaw))
+            return { ok: false, errorText: 'Invalid app json: frontend must be an object' };
+        const kind = asString(frontendRaw['kind']);
+        if (kind !== 'http')
+            return { ok: false, errorText: "Invalid app json: frontend.kind must be 'http'" };
+        const defaultPortRaw = frontendRaw['defaultPort'];
+        const defaultPort = defaultPortRaw === undefined
+            ? undefined
+            : typeof defaultPortRaw === 'number' && Number.isFinite(defaultPortRaw)
+                ? Math.floor(defaultPortRaw)
+                : null;
+        if (defaultPort === null || (defaultPort !== undefined && defaultPort < 0)) {
+            return {
+                ok: false,
+                errorText: 'Invalid app json: frontend.defaultPort must be a non-negative number',
+            };
+        }
+        const basePath = asString(frontendRaw['basePath']) ?? undefined;
+        const wsPath = asString(frontendRaw['wsPath']) ?? undefined;
+        frontend = { kind: 'http', defaultPort, basePath, wsPath };
+    }
+    const contributesRaw = v['contributes'];
+    let contributes;
+    if (contributesRaw !== undefined) {
+        if (!isRecord(contributesRaw))
+            return { ok: false, errorText: 'Invalid app json: contributes must be an object' };
+        const teammatesYamlRelPath = asString(contributesRaw['teammatesYamlRelPath']) ?? undefined;
+        const toolsetsRaw = contributesRaw['toolsets'];
+        let toolsets;
+        if (toolsetsRaw !== undefined) {
+            if (!Array.isArray(toolsetsRaw)) {
+                return { ok: false, errorText: 'Invalid app json: contributes.toolsets must be an array' };
+            }
+            toolsets = [];
+            for (let i = 0; i < toolsetsRaw.length; i += 1) {
+                const parsed = parseToolsetJson(toolsetsRaw[i], `contributes.toolsets[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                toolsets.push(parsed.toolset);
+            }
+        }
+        const dialogRunControlsRaw = contributesRaw['dialogRunControls'];
+        let dialogRunControls;
+        if (dialogRunControlsRaw !== undefined) {
+            if (!Array.isArray(dialogRunControlsRaw)) {
+                return { ok: false, errorText: 'Invalid app json: contributes.dialogRunControls must be an array' };
+            }
+            dialogRunControls = [];
+            for (let i = 0; i < dialogRunControlsRaw.length; i += 1) {
+                const parsed = parseDialogRunControlJson(dialogRunControlsRaw[i], `contributes.dialogRunControls[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                dialogRunControls.push(parsed.control);
+            }
+        }
+        const reminderOwnersRaw = contributesRaw['reminderOwners'];
+        let reminderOwners;
+        if (reminderOwnersRaw !== undefined) {
+            if (!Array.isArray(reminderOwnersRaw)) {
+                return { ok: false, errorText: 'Invalid app json: contributes.reminderOwners must be an array' };
+            }
+            reminderOwners = [];
+            for (let i = 0; i < reminderOwnersRaw.length; i += 1) {
+                const parsed = parseReminderOwnerJson(reminderOwnersRaw[i], `contributes.reminderOwners[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                reminderOwners.push(parsed.owner);
+            }
+        }
+        contributes = { teammatesYamlRelPath, toolsets, dialogRunControls, reminderOwners };
+    }
+    return {
+        ok: true,
+        json: {
+            schemaVersion: 1,
+            appId,
+            displayName,
+            package: { name: packageName, version: packageVersion, rootAbs },
+            host: { kind: 'node_module', moduleRelPath, exportName },
+            frontend,
+            contributes,
+        },
+    };
+}

package/dist/diligence.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageCode } from './types/language';
+export declare const DEFAULT_DILIGENCE_PUSH_MAX = 3;
+export declare const DILIGENCE_FALLBACK_TEXT: Readonly<Record<LanguageCode, string>>;

package/dist/diligence.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DILIGENCE_FALLBACK_TEXT = exports.DEFAULT_DILIGENCE_PUSH_MAX = void 0;
+exports.DEFAULT_DILIGENCE_PUSH_MAX = 3;
+exports.DILIGENCE_FALLBACK_TEXT = {
+    zh: [
+        '你扪心自问（做一次 FBR），差遣牒已经包含足够明确的目标定义了吗？',
+        '',
+        '如果没有，使用 `askHuman` 请求人类给出足够清晰的目标。',
+        '',
+        '如果目标已经清晰定义，那么你已经完成了所有目标吗？',
+        '',
+        '如果已经完成，使用 `askHuman` 请求人类验收。',
+        '',
+        '如果尚未完成，优先直接确定并执行下一步最优行动项（调用工具或诉请队友）。仅当“下一步不清晰/难以决策”时，才发起一次 freshBootsReasoning 扪心自问（FBR）；收齐该次回贴后，立即把结论落地为可执行动作并开始执行，不要只汇报决定。',
+        '',
+        '当你确信自己不该或者不能自主继续工作时，立即使用 `askHuman` 请求人类确认相关问题或者指出工作方向。',
+        '',
+        '---',
+        '',
+        '**注意**：',
+        '',
+        '扪心自问时，自诉请正文需要包含对当前状况的完整事实性总结（但不要包含差遣牒已有内容）；发起 freshBootsReasoning 后不要立即下最终行动决策，先等回贴再综合。综合完成后必须立刻执行已确定行动（工具调用/诉请队友），避免停留在“仅汇报决定”的状态。',
+        '',
+        '队友如果回复 “将要/可以” 做 XXX 的，你要审视祂所说是否符合整体/分项任务目标，是否值得继续：',
+        '- 如果祂建议的事情可做可不做，那么就可以忽略，不以琐碎小事安排工作。',
+        '- 如果值得继续，你可加以纠正或鼓励，并立即诉请其继续，不要留祂停在那里等待指令，这是不可接受的。',
+        '',
+        '系统会在首次出现“尚未收到反馈、仍在执行中的诉请”时自动添加提醒项，并在状态变化时自动刷新；诉请全部结束后不会自动删除该提醒项。',
+        '',
+        '当该提醒项明确写出“当前没有任何执行中的诉请、没有其祂智能体在后台工作”时，任何“继续等待”的想法和行为都是错误的；如果你已经明确知晓这点，可手动删除该提醒项以免碍眼。',
+        '',
+        '同理，若不存在“⏳ 进行中诉请（共 N 路，自动添加，手动删除）”这类提醒项，或某条历史诉请未出现在该提醒项中，都表示当前没有可等待的进行中诉请（通常代表该轮已回贴或已结束）；“继续等待”是错误动作，必须立即执行下一步：本地动作，或使用同一个 `sessionSlug` 再次调用 `tellask` 向对应队友发起下一轮诉请。',
+    ].join('\n'),
+    en: [
+        'Do a self-check (run one FBR): does the Taskdoc already contain a sufficiently clear goal definition?',
+        '',
+        'If not, use `askHuman` to request a sufficiently clear goal.',
+        '',
+        'If the goal is already clearly defined, ask: have you completed all goals?',
+        '',
+        'If yes, use `askHuman` to request acceptance.',
+        '',
+        'If not complete, first determine and execute the best next action (tool call or teammate tellask). Use freshBootsReasoning for FBR only when the next move is unclear or hard to decide; after feedback from that FBR run is collected, immediately turn the conclusion into executable action and start execution. Do not stop at reporting a decision.',
+        '',
+        'When you are convinced you should not or cannot continue autonomously, immediately use `askHuman` to confirm the relevant issue or provide direction.',
+        '',
+        '---',
+        '',
+        '**Notes**:',
+        '',
+        'When running FBR, the FBR body must include a complete factual summary of the current situation (but do not repeat information already present in the Taskdoc). After initiating a freshBootsReasoning, do not finalize the next action immediately; wait for feedback first, then synthesize. Once synthesized, immediately execute the chosen action (tool call / teammate tellask), and avoid staying in a “decision report only” state.',
+        '',
+        'If a teammate replies that they “will/can do X”, examine whether it aligns with the overall/sub-task goals and is worth continuing:',
+        '- If it is optional and low impact, ignore it instead of assigning trivial work.',
+        '- If it is worth continuing, correct or encourage as needed and immediately tellask them to continue; leaving them idle and waiting for instructions is unacceptable.',
+        '',
+        'The system auto-adds this reminder when still-running Tellasks first appear and auto-refreshes it as status changes; after all Tellasks finish, it is not auto-deleted.',
+        '',
+        'When this reminder explicitly says there are no in-flight Tellasks and no agents working in the background, any “keep waiting” thought or behavior is wrong; if you clearly know this, manually delete the reminder to reduce noise.',
+        '',
+        'Likewise, if a “⏳ In-flight Tellasks (N total, auto-added, manually deleted)” reminder is absent, or a historical Tellask is not listed in that reminder, there is no waitable in-flight Tellask for it at the moment (usually the previous round has replied or ended). “Keep waiting” is a wrong action; execute the next step immediately: local action, or launch a new Tellask round to the same teammate via `tellask` with the same `sessionSlug`.',
+    ].join('\n'),
+};

package/dist/evt.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Event processing constructs equivalent to Edh's:
+ * - PubChan: write-only broadcast channel
+ * - SubChan: read-only subscriber channel
+ * - EventSink: event source with sequence and most-recent value, streaming support
+ *
+ * Notes:
+ * - PubChan behaves like a broadcast channel: if there is no SubChan reading, writes are effectively dropped
+ * - SubChan buffers unboundedly relative to its own consumption speed
+ * - EndOfStream sentinel signals termination of streams
+ */
+export declare const EndOfStream: unique symbol;
+export type EOS = typeof EndOfStream;
+type NodeValue<T> = readonly [value: T | EOS, next: Promise<NodeValue<T>>];
+export declare class PubChan<T> {
+    private nxt;
+    write(ev: T | EOS): void;
+    get nextPromise(): Promise<NodeValue<T>>;
+}
+export declare class SubChan<T> {
+    private nxtP;
+    readonly cancelled: Promise<void>;
+    readonly cancel: () => void;
+    constructor(pub: PubChan<T>);
+    read(): Promise<T | EOS>;
+    stream(): AsyncGenerator<T, void, void>;
+}
+export declare class EventSink<T> {
+    private seqn;
+    private mrv;
+    private readonly chan;
+    get eos(): boolean;
+    publish(ev: T | EOS): void;
+    one_more(): Promise<T | EOS>;
+    stream(): AsyncGenerator<T, void, void>;
+}
+export declare function createPubChan<T>(): PubChan<T>;
+export declare function createSubChan<T>(pub: PubChan<T>): SubChan<T>;
+export declare function createEventSink<T>(): EventSink<T>;
+export {};