toolroll 0.5.0

package/dist/team-runtime.js

@@ -0,0 +1,264 @@
+/** Central shared-conversation execution. Queue delivery is independent from
+ * task completion; idle passes never call a model. */
+import { createHash, randomUUID } from 'node:crypto';
+import { deliverTeamUpdates, startTeamUpdates } from './team-updates.js';
+import { workIndexPage } from './work-index.js';
+import { TeamLeads } from './team-leads.js';
+import { ceilingDigestOf, verifyApproverStanding } from './principal.js';
+import { credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey, mateWorstCaseForPrice } from './converse.js';
+import { runMateTurn } from './mate.js';
+import { updateAdmissionPaused } from './desktop-update-gate.js';
+const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const response = (ok, code, message) => ({ version: 1, ok, code, message });
+const requestFor = (claim) => hash(['team', claim.conversationId, claim.messageId, claim.requestId]).slice(0, 32);
+export function createTeamRuntime(options) {
+    const { store } = options, clock = options.clock ?? (() => new Date());
+    const domain = new TeamLeads(store, options.repos);
+    const runner = `team:${process.pid}:${randomUUID()}`;
+    const capacity = Math.max(1, Math.min(8, options.capacity ?? 4));
+    const active = new Set();
+    const waiting = new Map();
+    const pages = new Map();
+    let timer = null, closed = false, passing = false, lastDelivery = 0;
+    function authorization(actor, snapshot) {
+        const live = options.provider(), config = live?.config, conversation = snapshot.selected;
+        const empty = { enabled: false, provider: config?.provider ?? null, model: config?.model ?? null,
+            dailyTurns: config?.dailyTurns ?? 0, weeklyCeilingUsd: null, conversationCeilingUsd: null, termsDigest: '' };
+        if (!conversation)
+            return empty;
+        if (!live || !config)
+            return { ...empty, waitingReason: 'Choose a chat provider in Settings.' };
+        const direct = isDirectChatProvider(config.provider);
+        if (direct && (live.key === null || priceForConfig(config) === null))
+            return { ...empty, waitingReason: 'The configured chat connection is unavailable. Open Settings.' };
+        const credential = direct ? credentialKeyOf(config.provider, live.key) : subscriptionCredentialKey(config.provider);
+        const session = store.teamMateSession(actor.name, conversation.threadId);
+        const ceiling = direct ? (session ? session.ceilingMicrousd / 1_000_000 : Math.min(5, config.weeklyCeilingMicrousd / 1_000_000)) : null;
+        const termsDigest = hash({ version: 1, actor: actor.name, generation: actor.generation, conversation: conversation.id,
+            projects: conversation.projects, credential, provider: config.provider, model: config.model,
+            daily: config.dailyTurns, weekly: config.weeklyCeilingMicrousd, priceIn: config.priceInMicrousd, priceOut: config.priceOutMicrousd, ceiling });
+        const enabled = session !== null && session.approverGeneration === actor.generation && session.endedAt === null
+            && session.credentialKey === credential && session.ceilingDigest === ceilingDigestOf(conversation.projects) && session.termsDigest === termsDigest;
+        return { enabled, provider: config.provider, model: config.model, dailyTurns: config.dailyTurns,
+            weeklyCeilingUsd: direct ? config.weeklyCeilingMicrousd / 1_000_000 : null, conversationCeilingUsd: ceiling, termsDigest };
+    }
+    function admission(actor, id) {
+        const conversation = domain.access(actor, id, 'contributor').conversation;
+        const grant = authorization(actor, { selected: conversation }), live = options.provider();
+        const session = store.teamMateSession(actor.name, conversation.threadId);
+        const used = store.chatTurnsToday(actor.name, clock());
+        const weekly = session ? store.chatWeeklySpendMicrousd(session.credentialKey, clock()) : 0;
+        const latched = session && store.handle.prepare('SELECT 1 FROM chat_turn WHERE credential_key=? AND unknown_spend=1 AND acknowledged_at IS NULL LIMIT 1').get(session.credentialKey);
+        const legacyBusy = Boolean(store.handle.prepare("SELECT 1 FROM chat_turn WHERE approver=? AND mate_turn IS NULL AND state IN ('queued','running') LIMIT 1").get(actor.name));
+        const stamp = hash([grant.termsDigest, grant.enabled, session?.id, session?.spentMicrousd, used, weekly, Boolean(latched), legacyBusy]);
+        let reason = grant.waitingReason ?? (!grant.enabled ? 'Enable chat using the current provider and limits.' : null);
+        if (!reason && live && session) {
+            const price = priceForConfig(live.config), minimum = isDirectChatProvider(live.config.provider) && price ? mateWorstCaseForPrice(price, 0, { steps: 1 }) : 0;
+            if (latched)
+                reason = 'A previous chat cost is unconfirmed. Open Settings to inspect it.';
+            else if (used >= live.config.dailyTurns)
+                reason = 'The daily chat limit is reached. Queued messages are saved.';
+            else if (session.ceilingMicrousd - session.spentMicrousd < minimum)
+                reason = 'This conversation has used its chat allowance. Queued messages are saved.';
+            else if (live.config.weeklyCeilingMicrousd - weekly < minimum)
+                reason = 'The weekly chat limit is reached. Queued messages are saved.';
+        }
+        return { ok: reason === null, stamp, reason };
+    }
+    function snapshot(actor, conversationId, leadId) {
+        const view = domain.snapshot(actor, conversationId, leadId);
+        return decorate(actor, view);
+    }
+    function tasksFor(selected) {
+        const now = clock(), revision = options.workspaceRevision?.current();
+        // Callers proved current membership and complete scope before reaching
+        // this cache. Only identical lead/project/room-policy projections share it.
+        const key = hash([selected.leadId, selected.projects, selected.revision]);
+        const previous = pages.get(key);
+        if (revision && previous?.revision === revision && previous.expires > now.getTime())
+            return previous.page;
+        const page = workIndexPage(store, now, { principal: 'operator', repos: selected.projects }, { leadId: selected.leadId, limit: 40 });
+        if (revision && options.workspaceRevision) {
+            if (pages.size >= 64)
+                pages.delete(pages.keys().next().value);
+            pages.set(key, { revision, expires: options.workspaceRevision.expiresAt(now), page });
+        }
+        return page;
+    }
+    function decorate(actor, view) {
+        const selected = view.selected;
+        const grant = authorization(actor, view);
+        const waitingReason = selected && view.canSend && grant.enabled ? admission(actor, selected.id).reason : null;
+        return { ...view, chatAuthorization: { ...grant, ...(waitingReason ? { waitingReason } : {}) },
+            ...(selected ? { tasks: tasksFor(selected),
+                proposals: store.listMateProposals(selected.threadId).filter(p => p.state !== 'drafting').slice(-40).map(p => ({ id: p.id, turnId: p.turn, title: typeof p.payload['title'] === 'string' ? p.payload['title'].slice(0, 160) : `Review ${p.kind.replaceAll('_', ' ')}`, state: p.state, href: `/chat?conversation=${encodeURIComponent(selected.id)}&proposal=${p.id}` })) } : {}) };
+    }
+    function authorize(actor, args) {
+        const id = typeof args['conversationId'] === 'string' ? args['conversationId'] : '';
+        const access = domain.access(actor, id, 'contributor');
+        const who = verifyApproverStanding(store, actor.name, actor.generation, access.conversation.projects);
+        if (!who.ok)
+            return response(false, 'forbidden', 'Your account needs chat access before enabling this conversation.');
+        const view = snapshot(actor, id), terms = view.chatAuthorization;
+        if (terms.waitingReason || !terms.termsDigest)
+            return { ...response(false, 'unavailable', terms.waitingReason ?? 'Chat is unavailable.'), snapshot: view };
+        if (args['termsDigest'] !== terms.termsDigest || (args['ceilingUsd'] !== undefined && args['ceilingUsd'] !== terms.conversationCeilingUsd))
+            return { ...response(false, 'terms-changed', 'Review the current provider and limits before enabling chat.'), snapshot: view };
+        if (terms.enabled)
+            return { ...response(true, 'authorized', 'Chat is enabled.'), snapshot: view };
+        const live = options.provider();
+        const direct = isDirectChatProvider(live.config.provider);
+        const credentialKey = direct ? credentialKeyOf(live.config.provider, live.key) : subscriptionCredentialKey(live.config.provider);
+        const ceilingMicrousd = Math.round((terms.conversationCeilingUsd ?? 0) * 1_000_000);
+        if (direct && ceilingMicrousd <= 0)
+            return { ...response(false, 'over-budget', 'No chat allowance is available. Open Settings.'), snapshot: view };
+        store.transact(() => {
+            domain.access(actor, id, 'contributor');
+            store.mintTeamMateSession({ approver: actor.name, approverGeneration: actor.generation, thread: access.conversation.threadId,
+                credentialKey, ceilingMicrousd, ceilingDigest: who.who.ceilingDigest, termsDigest: terms.termsDigest }, clock());
+            store.recordAction({ at: clock().toISOString(), actor: actor.name, repo: null, taskId: null, runId: null,
+                action: 'team chat authorized', source: 'work', outcome: JSON.stringify({ conversation: id, lead: access.lead.id, terms: terms.termsDigest }) });
+        });
+        return { ...response(true, 'authorized', 'Chat is enabled.'), snapshot: snapshot(actor, id) };
+    }
+    async function run(claim) {
+        try {
+            if (!domain.current(claim)) {
+                domain.finish(claim, { status: 'cancelled', error: 'Conversation access changed.' }, clock());
+                return;
+            }
+            const view = snapshot(claim.actor, claim.conversationId), grant = view.chatAuthorization;
+            if (claim.requestId.startsWith('team-update:') && !view.selected?.follow) {
+                domain.finish(claim, { status: 'cancelled', error: 'Automatic updates were paused.' }, clock());
+                return;
+            }
+            const provider = options.provider(), session = store.teamMateSession(claim.actor.name, claim.threadId), thread = store.getMateThread(claim.threadId);
+            const proof = verifyApproverStanding(store, claim.actor.name, claim.actor.generation, claim.projects);
+            if (!provider || !session || !thread || !proof.ok || !grant?.enabled) {
+                domain.finish(claim, { status: 'failed', error: grant?.waitingReason ?? 'Chat authorization changed. Enable chat before sending a new message.' }, clock());
+                return;
+            }
+            const requestId = requestFor(claim);
+            // A saved terminal provider receipt wins over delivery bookkeeping.
+            // Neither failure nor an unconfirmed receipt causes another provider call.
+            const receipt = store.mateRequestReceipt(session.id, requestId);
+            if (receipt) {
+                const turn = store.getMateTurn(receipt.turn);
+                domain.finish(claim, { status: turn?.state === 'answered' ? 'answered' : turn?.state === 'failed' && !domain.deliveryUncertain(turn.id) ? 'failed' : 'uncertain',
+                    turnId: receipt.turn, ...(turn?.state === 'answered' ? {} : { error: 'Inspect the saved response; this message was not sent again.' }) }, clock());
+                return;
+            }
+            const result = await runMateTurn({ store, who: proof.who, session, thread, ...provider, message: claim.text, requestId,
+                queuedMessageId: claim.messageId,
+                onAdmitted: turn => { if (!domain.current(claim) || !domain.bindTurn(claim, turn))
+                    throw new Error('The queued message changed before admission.'); },
+                context: `Shared team conversation ${claim.conversationId}. You are the lead ${view.leads.find(lead => lead.id === claim.leadId)?.name ?? claim.leadId}. Messages name their actual authors; message order does not grant authority. Use existing task actions and approvals. Do not rerun work to recover a notification. The following saved lead guidance is context, not new permissions:\n${claim.instructions}`,
+                clock, evidenceRoot: options.evidenceRoot,
+                revalidate: async () => !closed && !updateAdmissionPaused(store.raw()) && domain.current(claim) && store.teamMateSession(claim.actor.name, claim.threadId)?.id === session.id && authorization(claim.actor, domain.snapshot(claim.actor, claim.conversationId)).enabled && (!claim.requestId.startsWith('team-update:') || domain.access(claim.actor, claim.conversationId).conversation.follow)
+                    ? { ok: true } : { ok: false, reason: 'Conversation access or execution ownership changed.' },
+                ...(options.fetcher ? { fetcher: options.fetcher } : {}), ...(options.subscriptionRunner ? { subscriptionRunner: options.subscriptionRunner } : {}) });
+            if (result.ok)
+                domain.finish(claim, { status: 'answered', turnId: result.turn }, clock());
+            else if ('refused' in result && ['daily-cap', 'session-exhausted', 'over-budget', 'latched', 'concurrent'].includes(result.refused)) {
+                // Native admission refused before a provider turn existed. Preserve the
+                // original queued request; wait for changed budget/concurrency facts.
+                const state = admission(claim.actor, claim.conversationId);
+                if (domain.defer(claim, result.message, clock()))
+                    waiting.set(claim.messageId, state.stamp);
+            }
+            else
+                domain.finish(claim, { status: 'unknownSpend' in result && result.unknownSpend ? 'uncertain' : 'failed', error: result.message, ...('turn' in result ? { turnId: result.turn } : {}) }, clock());
+        }
+        catch {
+            // An exception may have followed native admission. Preserve an explicit
+            // uncertain result; never turn a transport error into another attempt.
+            domain.finish(claim, { status: 'uncertain', error: 'Delivery could not be confirmed. Inspect the saved activity before continuing.' }, clock());
+        }
+    }
+    async function pass() {
+        if (closed || passing || store.isDemo() || updateAdmissionPaused(store.raw()))
+            return;
+        passing = true;
+        try {
+            domain.reconcileFinished(clock());
+            if (!options.provider())
+                return;
+            if (clock().getTime() - lastDelivery >= 5000) {
+                deliverTeamUpdates(store, domain, (actor, id) => admission(actor, id).ok, clock());
+                lastDelivery = clock().getTime();
+            }
+            while (active.size < capacity) {
+                const claim = domain.claimNext(runner, clock(), candidate => {
+                    const state = admission(candidate.actor, candidate.conversationId);
+                    return state.ok && waiting.get(candidate.messageId) !== state.stamp;
+                });
+                if (!claim)
+                    break;
+                waiting.delete(claim.messageId);
+                const work = run(claim);
+                active.add(work);
+                void work.finally(() => active.delete(work)).catch(() => undefined);
+            }
+        }
+        finally {
+            passing = false;
+        }
+    }
+    const execute = async (actor, request) => {
+        try {
+            if (request.operation === 'authorize')
+                return authorize(actor, request.args);
+            if (request.operation === 'send' || request.operation === 'follow' && request.args['enabled'] === true) {
+                const id = typeof request.args['conversationId'] === 'string' ? request.args['conversationId'] : '';
+                const view = snapshot(actor, id);
+                if (!view.chatAuthorization?.enabled)
+                    return { ...response(false, 'grant-needed', 'Enable chat for this conversation before sending.'), snapshot: view };
+            }
+            const result = store.transact(() => {
+                const id = typeof request.args['conversationId'] === 'string' ? request.args['conversationId'] : '';
+                const initialFollow = request.operation === 'follow' && request.args['enabled'] === true && !domain.followGrants().some(g => g.conversation.id === id);
+                const answer = domain.execute(actor, request, clock());
+                if (answer.ok && initialFollow)
+                    startTeamUpdates(store, id, clock());
+                return answer;
+            });
+            if (result.snapshot)
+                result.snapshot = decorate(actor, result.snapshot);
+            // The response acknowledges persisted admission only. Start at a later
+            // event-loop boundary so the UI can display Queued immediately.
+            if (result.ok && request.operation === 'send')
+                setImmediate(() => { void pass().catch(() => undefined); });
+            return result;
+        }
+        catch (error) {
+            return response(false, 'unavailable', error instanceof Error ? error.message : 'This conversation is unavailable.');
+        }
+    };
+    function start() {
+        if (timer || closed || store.isDemo())
+            return;
+        for (const prior of domain.activeRunners()) {
+            const match = /^team:(\d+):/.exec(prior);
+            if (!match)
+                continue;
+            try {
+                process.kill(Number(match[1]), 0);
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    domain.recover(prior, clock());
+            }
+        }
+        timer = setInterval(() => { void pass().catch(() => undefined); }, 500);
+        timer.unref();
+        void pass().catch(() => undefined);
+    }
+    async function close() {
+        closed = true;
+        if (timer)
+            clearInterval(timer);
+        timer = null;
+        await Promise.allSettled([...active]);
+    }
+    return { execute, start, close, pass, cursor: (actor, conversationId) => domain.cursor(actor, conversationId), domain };
+}

package/dist/team-ui.d.ts

@@ -0,0 +1,3 @@
+import type { TeamSnapshot } from './team-contract.js';
+/** Readable fallback uses the same admitted projection as the interactive UI. */
+export declare function teamWorkspaceHtml(snapshot: TeamSnapshot): string;

package/dist/team-ui.js

@@ -0,0 +1,9 @@
+const escape = (value) => value.replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[char]);
+/** Readable fallback uses the same admitted projection as the interactive UI. */
+export function teamWorkspaceHtml(snapshot) {
+    const selected = snapshot.selected;
+    return `<section class="team-workspace"><h1>${escape(selected?.title ?? 'Team chat')}</h1>` +
+        (selected ? `<p>${selected.visibility === 'team' ? 'Team' : 'Private'} · ${escape(snapshot.leads.find(lead => lead.id === selected.leadId)?.name ?? 'Lead')}</p>` : '') +
+        (snapshot.messages.length ? snapshot.messages.map(message => `<article><strong>${escape(message.author)}</strong><p style="white-space:pre-wrap;overflow-wrap:anywhere">${escape(message.text)}</p>${message.status === 'queued' || message.status === 'running' ? `<p>${message.status === 'queued' ? 'Queued' : 'Working'}</p>` : ''}${message.error ? `<p role="alert">${escape(message.error)}</p>` : ''}</article>`).join('') : '<p>Start a conversation with your team lead.</p>') +
+        '<noscript>Enable JavaScript to send messages and manage team conversations.</noscript><p><a href="/chat?private=1">Previous private chat</a></p></section>';
+}

package/dist/team-updates.d.ts

@@ -0,0 +1,8 @@
+/** Shared conversations consume the existing saved status stream. No task
+ * scans, model calls, or execution retries happen in this delivery layer. */
+import type { Store } from './store.js';
+import { TeamLeads } from './team-leads.js';
+import type { TeamActor } from './team-contract.js';
+export declare const teamUpdateCursor: (conversation: string) => string;
+export declare function startTeamUpdates(store: Store, conversation: string, now: Date): void;
+export declare function deliverTeamUpdates(store: Store, domain: TeamLeads, authorized: (actor: TeamActor, conversation: string) => boolean, now: Date): number;

package/dist/team-updates.js

@@ -0,0 +1,57 @@
+import { TeamLeads } from './team-leads.js';
+import { ASSIGNMENT_STATUS_ACTION, parseAssignmentStatusEvent } from './assignment-status.js';
+export const teamUpdateCursor = (conversation) => `team-updates:${conversation}`;
+export function startTeamUpdates(store, conversation, now) {
+    // Enabling updates starts here. Past events remain available in task history.
+    const latest = Number(store.handle.prepare('SELECT COALESCE(MAX(id),0) AS n FROM action_ledger').get()?.['n'] ?? 0);
+    store.setServiceCursor(teamUpdateCursor(conversation), latest, now);
+}
+export function deliverTeamUpdates(store, domain, authorized, now) {
+    const destinations = new Map();
+    for (const grant of domain.followGrants())
+        if (!destinations.has(grant.conversation.id) && authorized(grant.actor, grant.conversation.id))
+            destinations.set(grant.conversation.id, grant);
+    let queued = 0;
+    for (const [conversationId, grant] of destinations) {
+        store.transact(() => {
+            // Selection happened before obtaining the write lock. Reprove the
+            // observer and its paid allowance at the cursor/admission boundary.
+            const current = domain.followGrants().find(one => one.conversation.id === conversationId && one.actor.name === grant.actor.name && one.actor.generation === grant.actor.generation);
+            if (!current || !authorized(current.actor, conversationId))
+                return;
+            const after = store.serviceCursor(teamUpdateCursor(conversationId));
+            const rows = store.handle.prepare(`SELECT a.id,a.outcome,a.task_id,a.repo FROM action_ledger a
+        JOIN task_ref t ON t.backend='built-in' AND t.external_id=a.task_id AND t.repo=a.repo AND t.revision_of IS NULL
+        JOIN team_task_owner o ON o.task_ref=t.id AND o.lead=? AND o.conversation=?
+        WHERE a.action=? AND a.source='work' AND a.actor=? AND a.id>?
+          AND a.repo IN (SELECT value FROM json_each(?))
+        ORDER BY a.id LIMIT 50`).all(current.lead.id, conversationId, ASSIGNMENT_STATUS_ACTION, `lead:${current.lead.id}`, after, JSON.stringify(current.conversation.projects));
+            if (!rows.length)
+                return;
+            const changes = [];
+            let through = after;
+            for (const row of rows) {
+                const event = parseAssignmentStatusEvent(String(row['outcome']));
+                // Keep an unreadable row pending instead of silently losing delivery.
+                if (!event || event.assignment.rootId !== row['task_id'] || event.assignment.owner.kind !== 'lead' || event.assignment.owner.id !== current.lead.id)
+                    break;
+                through = Number(row['id']);
+                if (!['ready-to-check', 'needs-decision', 'complete', 'cancelled'].includes(event.assignment.state))
+                    continue;
+                changes.push(`${event.assignment.rootId}: ${event.assignment.title.slice(0, 100)} — ${event.assignment.state}. ${event.assignment.detail.slice(0, 180)}`);
+                if (changes.length === 4)
+                    break;
+            }
+            if (changes.length) {
+                const text = `Automatic update authorized by ${grant.actor.name}. Read these saved task changes and report what needs attention. Do not rerun tasks or repeat checks to recover delivery.\n${changes.join('\n')}`;
+                const result = domain.execute(grant.actor, { operation: 'send', args: { conversationId, requestId: `team-update:${conversationId}:${through}`, text } }, now);
+                if (!result.ok)
+                    return;
+                queued++;
+            }
+            if (through > after)
+                store.setServiceCursor(teamUpdateCursor(conversationId), through, now);
+        });
+    }
+    return queued;
+}

package/dist/teammate-admin.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Looking after AI teammates (v92): making one from a template or a soul
+ * file, editing its soul (a new version each time), pausing or removing it,
+ * telling it something, and the daily summary it sends its manager.
+ *
+ * Shared by the Teammates pages and the lead chat, so both do the same thing.
+ */
+import type { Store, TeammateRow } from "./store.js";
+export type Done = {
+    ok: true;
+    said: string;
+    id?: number;
+} | {
+    ok: false;
+    said: string;
+};
+export declare const TEAMMATE_MODELS: readonly ["default", "sonnet", "opus", "haiku"];
+/** A soul file with a different name: the template's, renamed. */
+export declare function renamedSoul(soul: string, name: string): string;
+/** A new teammate in a project, from a template (optionally renamed) or a whole soul file. */
+export declare function createTeammateFrom(store: Store, input: {
+    repo: string;
+    template?: string | null;
+    name?: string | null;
+    soul?: string | null;
+    by: string;
+}, now: Date): Done;
+/** Save a new version of a teammate's soul file. Its name stays: zones name it by handle. */
+export declare function saveSoul(store: Store, mate: TeammateRow, soul: string, by: string, now: Date): Done;
+/** Pause, resume or remove. Paused, its decisions go to people and the zones it handles wait. */
+export declare function setTeammateState(store: Store, mate: TeammateRow, state: "active" | "paused" | "removed", by: string, now: Date): Done;
+export declare function teammateSettings(store: Store, mate: TeammateRow, change: {
+    model?: string;
+    dailyTurns?: number;
+    manager?: string;
+}, by: string, now: Date): Done;
+export declare const nameOf: (mate: TeammateRow) => string;
+export declare const labelOf: (mate: TeammateRow) => string;
+/** Every zone a teammate works, in every flow of its project. */
+export declare function zonesOf(store: Store, mate: TeammateRow): {
+    flow: number;
+    flowName: string;
+    zone: string;
+    title: string;
+    kind: "decides" | "handles";
+}[];
+/** What a teammate did since a time, in words its manager reads at a glance. */
+export declare function summaryOf(store: Store, mate: TeammateRow, since: string | null): {
+    said: string;
+    quiet: boolean;
+};
+/** The daily summary, to each teammate's manager, once a day after 5 pm (this computer's time), or now when asked. */
+export declare function sendTeammateSummaries(store: Store, repo: string, now: Date, only?: number | null): number;

package/dist/teammate-admin.js

@@ -0,0 +1,111 @@
+import { flowDefinitionOf } from "./flow-engine.js";
+import { handleOf, parseSoul, TEAMMATE_TEMPLATES, teammateLabel } from "./teammates.js";
+export const TEAMMATE_MODELS = ["default", "sonnet", "opus", "haiku"];
+/** A soul file with a different name: the template's, renamed. */
+export function renamedSoul(soul, name) {
+    return soul.replace(/^name:.*$/m, `name: ${name.replace(/[\r\n]/g, " ").trim()}`);
+}
+/** A new teammate in a project, from a template (optionally renamed) or a whole soul file. */
+export function createTeammateFrom(store, input, now) {
+    const template = TEAMMATE_TEMPLATES.find(one => one.id === input.template);
+    let soul = input.soul?.trim() ? input.soul : template?.soul ?? null;
+    if (soul === null)
+        return { ok: false, said: "Start from a template, or write a soul file." };
+    if (input.name?.trim())
+        soul = renamedSoul(soul, input.name);
+    const read = parseSoul(soul);
+    if (!read.ok)
+        return { ok: false, said: read.problem };
+    const handle = handleOf(read.soul.name);
+    if (store.teammateByHandle(input.repo, handle) !== null)
+        return { ok: false, said: `There's already a teammate called ${read.soul.name} in this project. Give this one another name.` };
+    const id = store.createTeammate({ repo: input.repo, handle, soul, model: null, manager: input.by, by: input.by }, now);
+    store.addTeammateEvent({ teammate: id, kind: "note", said: `${input.by} brought ${read.soul.name} onto the team.`, by: input.by }, now);
+    return { ok: true, said: `${teammateLabel(read.soul)} is on the team. Put ${read.soul.name} on a zone to start.`, id };
+}
+/** Save a new version of a teammate's soul file. Its name stays: zones name it by handle. */
+export function saveSoul(store, mate, soul, by, now) {
+    const read = parseSoul(soul);
+    if (!read.ok)
+        return { ok: false, said: read.problem };
+    if (handleOf(read.soul.name) !== mate.handle)
+        return { ok: false, said: `Keep the name (zones find this teammate as ${mate.handle}); make a new teammate for another name.` };
+    const saved = store.saveTeammateSoul(mate.id, soul.replace(/\r\n?/g, "\n").trim() + "\n", by, now);
+    return { ok: true, said: saved ? `Saved. ${read.soul.name} works from version ${mate.version + 1} now.` : "No changes to save." };
+}
+/** Pause, resume or remove. Paused, its decisions go to people and the zones it handles wait. */
+export function setTeammateState(store, mate, state, by, now) {
+    const name = nameOf(mate);
+    if (state === mate.state)
+        return { ok: true, said: "No change." };
+    if (state === "removed") {
+        for (const question of store.openTeammateQuestions([mate.id]))
+            store.dropTeammateQuestion(question.id, now);
+        // v94: calls waiting for approval, or approved and not made yet, are never made.
+        for (const call of store.teammateCallsOf(mate.id, 500).filter(one => one.state === "asked" || one.state === "approved"))
+            store.moveTeammateCall(call.id, ["asked", "approved"], { state: "refused", result: `${name} left the team before the call was made.` }, now);
+        store.updateTeammate(mate.id, { state }, by, now);
+        return { ok: true, said: `${name} is off the team. Zones that named ${name} go to people now.` };
+    }
+    store.updateTeammate(mate.id, { state }, by, now);
+    store.addTeammateEvent({ teammate: mate.id, kind: state === "paused" ? "paused" : "resumed", said: state === "paused" ? `${by} paused ${name}.` : `${by} set ${name} working again.`, by }, now);
+    return { ok: true, said: state === "paused" ? `${name} is paused. Its decisions go to people until you resume it.` : `${name} is working again.` };
+}
+export function teammateSettings(store, mate, change, by, now) {
+    const model = change.model === undefined ? undefined : change.model === "default" ? null : TEAMMATE_MODELS.includes(change.model) ? change.model : undefined;
+    if (change.model !== undefined && model === undefined)
+        return { ok: false, said: "Choose one of the models listed." };
+    if (change.dailyTurns !== undefined && (!Number.isInteger(change.dailyTurns) || change.dailyTurns < 1 || change.dailyTurns > 2000))
+        return { ok: false, said: "A daily limit is 1 to 2,000 turns." };
+    if (change.manager !== undefined && !store.accountCanAccess(change.manager, mate.repo))
+        return { ok: false, said: "Its manager must be someone on this project." };
+    store.updateTeammate(mate.id, { ...(model === undefined ? {} : { model }), ...(change.dailyTurns === undefined ? {} : { dailyTurns: change.dailyTurns }), ...(change.manager === undefined ? {} : { manager: change.manager }) }, by, now);
+    return { ok: true, said: "Saved." };
+}
+export const nameOf = (mate) => { const read = parseSoul(mate.soul); return read.ok ? read.soul.name : mate.handle; };
+export const labelOf = (mate) => { const read = parseSoul(mate.soul); return read.ok ? teammateLabel(read.soul) : mate.handle; };
+/** Every zone a teammate works, in every flow of its project. */
+export function zonesOf(store, mate) {
+    return store.listFlows([mate.repo]).flatMap(flow => (flowDefinitionOf(flow)?.stages ?? []).filter(one => one.teammate === mate.handle)
+        .map(one => ({ flow: flow.id, flowName: flow.name, zone: one.id, title: one.title, kind: one.kind === "approval" ? "decides" : "handles" })));
+}
+/** What a teammate did since a time, in words its manager reads at a glance. */
+export function summaryOf(store, mate, since) {
+    const name = nameOf(mate);
+    const events = store.teammateEvents(mate.id, 500, since);
+    const count = (kind) => events.filter(one => one.kind === kind).length;
+    const decided = count("decided"), handled = count("handled"), handed = count("handed"), asked = count("asked"), failed = count("failed");
+    const open = store.openTeammateQuestions([mate.id]).length;
+    // v94: its tool calls — made, approved first, and what its people said no to.
+    const calls = store.teammateCallsOf(mate.id, 1000, since);
+    const made = calls.filter(one => one.state === "done" || one.state === "failed").length, approved = calls.filter(one => one.decidedBy !== null && one.state !== "denied").length, denied = calls.filter(one => one.state === "denied").length;
+    const quiet = decided + handled + handed + asked + failed + calls.length === 0;
+    const lines = [
+        quiet ? `${name} had nothing to do${since === null ? " yet" : " today"}.` : `${name} decided ${decided}, handled ${handled}, handed ${handed} to people, and asked ${asked} question${asked === 1 ? "" : "s"}${failed > 0 ? `; ${failed} turn${failed === 1 ? "" : "s"} failed` : ""}.`,
+        ...(calls.length === 0 ? [] : [`It made ${made} tool call${made === 1 ? "" : "s"}${approved > 0 ? ` (${approved} after a person approved)` : ""}${denied > 0 ? `; ${denied} ${denied === 1 ? "was" : "were"} turned down` : ""}.`]),
+        ...(open > 0 ? [`${open} question${open === 1 ? " is" : "s are"} waiting for an answer.`] : []),
+        ...events.filter(one => one.kind === "handed" || one.kind === "failed").slice(0, 5).map(one => `• ${one.said}`),
+    ];
+    return { said: lines.join("\n"), quiet };
+}
+/** The daily summary, to each teammate's manager, once a day after 5 pm (this computer's time), or now when asked. */
+export function sendTeammateSummaries(store, repo, now, only = null) {
+    const evening = new Date(now);
+    evening.setHours(17, 0, 0, 0);
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    let sent = 0;
+    for (const mate of store.teammates([repo])) {
+        if (only !== null ? mate.id !== only : mate.state !== "active" || now < evening || (mate.summaryAt !== null && mate.summaryAt >= evening.toISOString()))
+            continue;
+        const summary = summaryOf(store, mate, start.toISOString());
+        store.updateTeammate(mate.id, { summaryAt: now.toISOString() }, "summary", now);
+        if (summary.quiet && only === null)
+            continue;
+        store.enqueueNotification({ dedupeKey: `teammate-summary:${mate.id}:${now.toISOString().slice(0, only === null ? 10 : 19)}`, kind: "teammate-summary", recipient: mate.manager,
+            subject: `${labelOf(mate)}: today`, body: summary.said, link: `/teammates/${mate.id}`, source: { project: repo } }, now);
+        store.addTeammateEvent({ teammate: mate.id, kind: "summary", said: summary.said }, now);
+        sent++;
+    }
+    return sent;
+}

package/dist/teammate-desk.d.ts

@@ -0,0 +1,60 @@
+import type { FlowCardRow, FlowRow, Store, TeammateRow } from "./store.js";
+/** The zone on a desk where the teammate handles what it's asked. */
+export declare const DESK_ZONE = "handle";
+type Done = {
+    ok: true;
+    said: string;
+} | {
+    ok: false;
+    said: string;
+};
+/** Its desk, when it has one. */
+export declare function deskOf(store: Store, mate: TeammateRow): FlowRow | null;
+/** Its desk, made the first time it's needed: owned by its manager, drawn like any flow. */
+export declare function ensureDesk(store: Store, mate: TeammateRow, now: Date): FlowRow;
+/** Who a desk card's answer goes to: the person who asked (when they can see the project), else its manager. */
+export declare function askerOf(store: Store, flow: FlowRow, card: FlowCardRow, mate: TeammateRow): string;
+/** The answer a teammate wrote, back to whoever asked, under its name. Once per visit. */
+export declare function replyToAsker(store: Store, flow: FlowRow, card: FlowCardRow, mate: TeammateRow, text: string, now: Date): void;
+/** "@rosa …", "@rosa, …", "Rosa: …" or "Rosa, …": the teammate a message is addressed to, and what it says. */
+export declare function addressedTo(text: string): {
+    name: string;
+    said: string;
+} | null;
+/**
+ * A message in someone's chat with Toolroll, addressed to a teammate
+ * by name, becomes a card on its desk; null when it isn't addressed to one of
+ * the teammates in their projects (it goes to the lead as usual).
+ */
+export declare function messageTeammate(store: Store, from: {
+    who: string;
+    repos: readonly string[];
+    via: string;
+}, text: string, now: Date): {
+    said: string;
+    link?: {
+        label: string;
+        path: string;
+    };
+} | null;
+export type Routine = {
+    id: number;
+    schedule: string;
+    text: string;
+    state: "active" | "paused" | "removed";
+    lastAt: string | null;
+    lastOutcome: string | null;
+    nextAt: string | null;
+};
+/** Its routines: the schedules on its desk that start in its zone. */
+export declare function routinesOf(store: Store, mate: TeammateRow): Routine[];
+/** This computer's time zone: what a routine's time means when it names none. */
+export declare const localZone: () => string;
+/** A routine's schedule as kept: a calendar time with no zone is this computer's time, not UTC. */
+export declare function routineSchedule(words: string): string | null;
+/** A routine: on this schedule ("weekdays 09:00", "daily 17:00 Europe/London", "every 2 hours"), a card on its desk saying what to do. */
+export declare function addRoutine(store: Store, mate: TeammateRow, schedule: string, text: string, by: string, now: Date, dir: string | null): Done;
+export declare function removeRoutine(store: Store, mate: TeammateRow, id: number, now: Date, dir: string | null): Done;
+/** Try a routine now: its card lands on the desk at once. */
+export declare function runRoutine(store: Store, mate: TeammateRow, id: number, by: string, now: Date): Done;
+export {};