crewly 1.20.179 → 1.20.180

package/dist/backend/backend/src/services/decisions/decision.service.js

@@ -0,0 +1,639 @@
+/**
+ * Decision cards (specs/2026-10-01-decision-cards.md).
+ *
+ * The responsible agent asks the owner ONE structured question; its own
+ * Slack bot posts a Block Kit card in the team channel (the ticket's thread,
+ * or a new thread), and the owner answers with a button, a reaction, a
+ * thread reply or the dashboard. The answer updates the card in place, goes
+ * into the ticket log, is delivered to the asking agent and clears the
+ * owner-message watchdog for that thread. At the deadline the default is
+ * applied — except for sensitive asks, which are re-asked once and parked.
+ *
+ * Every collaborator is injected ({@link DecisionServiceDeps}); the wiring
+ * with the real Slack / tickets / agents lives in `decision.wiring.ts`.
+ *
+ * @module services/decisions/decision.service
+ */
+import { DECISION_CONSTANTS, ORCHESTRATOR_SESSION_NAME } from '../../constants.js';
+import { LoggerService } from '../core/logger.service.js';
+import { DecisionContractError, validateAskOwner } from './decision-contract.js';
+import { cardFallbackText, choiceFromReaction, choiceFromText, deadlineDefaultLine, defaultLabel, formatWhen, optionLabel, parseButtonValue, renderOpenCard, renderSettledCard, settledLine, ticketThreadRootText, } from './decision-card.js';
+import { PENDING_DECISION_STATUSES } from './decision-store.js';
+/** Thrown for requests the caller must fix (HTTP 4xx). */
+export class DecisionError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'DecisionError';
+    }
+}
+/**
+ * Next local `hour`:00 strictly tomorrow.
+ *
+ * @param now - Clock
+ * @param hour - Local hour
+ * @returns Date
+ */
+function tomorrowAt(now, hour) {
+    const d = new Date(now.getTime());
+    d.setDate(d.getDate() + 1);
+    d.setHours(hour, 0, 0, 0);
+    return d;
+}
+/**
+ * Decision cards service.
+ */
+export class DecisionService {
+    static instance = null;
+    deps;
+    logger;
+    now;
+    timer = null;
+    ticking = false;
+    /**
+     * @param deps - Collaborators
+     */
+    constructor(deps) {
+        this.deps = deps;
+        this.logger = deps.logger ?? LoggerService.getInstance().createComponentLogger('DecisionCards');
+        this.now = deps.now ?? (() => new Date());
+    }
+    /** @returns The process-wide instance, or null before wiring */
+    static getInstance() {
+        return DecisionService.instance;
+    }
+    /** @param service - Instance to install (null clears) */
+    static setInstance(service) {
+        DecisionService.instance = service;
+    }
+    /** Start the deadline / reminder tick. */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => void this.tick(), DECISION_CONSTANTS.TICK_MS);
+        this.timer.unref?.();
+    }
+    /** Stop the tick. */
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    // ---------------------------------------------------------------------------
+    // Asking
+    // ---------------------------------------------------------------------------
+    /**
+     * Ask the owner. Validates the contract, stores the decision and posts the
+     * card as the responsible agent's own bot.
+     *
+     * @param callerSession - Agent calling ask-owner (undefined = owner / dashboard)
+     * @param input - The ask
+     * @returns The stored decision (with `card`, or `postError` when Slack refused; retried on the tick)
+     * @throws DecisionError(400) for a contract violation, other 4xx from ticket resolution
+     */
+    async ask(callerSession, input) {
+        let ask;
+        try {
+            ask = validateAskOwner(input, this.now());
+        }
+        catch (err) {
+            if (err instanceof DecisionContractError)
+                throw new DecisionError(400, err.message);
+            throw err;
+        }
+        let asker = callerSession;
+        let ticket;
+        let teamId;
+        if (ask.ticketId && ask.project) {
+            const ctx = await this.deps.resolveTicket(ask.project, ask.ticketId, callerSession);
+            asker = ctx.asker;
+            teamId = ctx.teamId;
+            ticket = { projectId: ctx.projectId, projectPath: ctx.projectPath, projectName: ctx.projectName, id: ctx.id, title: ctx.title };
+        }
+        if (!asker)
+            throw new DecisionError(400, 'Who is asking? Run ask-owner from an agent session, or name a --ticket.');
+        if (!teamId)
+            teamId = await this.deps.teamOf(asker).catch(() => undefined);
+        const workItemId = callerSession ? await this.deps.currentWorkItemId?.(callerSession).catch(() => undefined) : undefined;
+        const decision = await this.deps.store.create({
+            question: ask.question,
+            options: ask.options,
+            defaultKey: ask.defaultKey,
+            deadline: ask.deadline.toISOString(),
+            ...(ask.sensitive ? { sensitive: ask.sensitive } : {}),
+            requestedBy: callerSession ?? 'owner',
+            asker,
+            ...(ticket ? { ticket } : {}),
+            ...(teamId ? { teamId } : {}),
+            ...(workItemId ? { workItemId } : {}),
+            status: 'open',
+        });
+        if (ticket && ask.ticketId && ask.project) {
+            await this.deps
+                .markTicketAsked({ ...ticket, asker, teamId }, ask.question, decision.id)
+                .catch((err) => this.logger.warn('Could not mark the ticket as waiting on the owner', { decisionId: decision.id, error: errText(err) }));
+        }
+        this.logger.info('Owner decision asked', { decisionId: decision.id, asker, requestedBy: decision.requestedBy, ticket: ticket?.id, sensitive: decision.sensitive });
+        return this.postCard(decision);
+    }
+    /**
+     * Post (or re-try posting) the card of an open decision.
+     *
+     * @param decision - Decision without a card
+     * @returns The decision with `card` or `postError`
+     */
+    async postCard(decision) {
+        const slack = this.deps.slack();
+        if (!slack || !slack.isConnected()) {
+            return (await this.deps.store.update(decision.id, () => ({ postError: 'Slack is not connected' }))) ?? decision;
+        }
+        try {
+            const identity = await this.deps.identityOf(decision.asker);
+            const place = await this.placeFor(decision, identity, slack);
+            const blocks = renderOpenCard(decision, this.deps.instanceId(), this.now());
+            const { ts, ownBot } = await this.send(slack, identity, {
+                channelId: place.slackChannelId,
+                text: cardFallbackText(decision),
+                blocks,
+                ...(place.threadTs ? { threadTs: place.threadTs } : {}),
+            });
+            const updated = await this.deps.store.update(decision.id, () => ({
+                card: {
+                    slackChannelId: place.slackChannelId,
+                    messageTs: ts,
+                    ...(place.threadTs ? { threadTs: place.threadTs } : {}),
+                    postedBy: ownBot ? decision.asker : 'crewly',
+                    ownBot,
+                },
+                ...(place.teamId && !decision.teamId ? { teamId: place.teamId } : {}),
+                postError: undefined,
+            }));
+            this.logger.info('Decision card posted', { decisionId: decision.id, channel: place.slackChannelId, threaded: !!place.threadTs, ownBot });
+            return updated ?? decision;
+        }
+        catch (err) {
+            const msg = err instanceof DecisionError ? err.message : errText(err);
+            this.logger.warn('Decision card not posted (retried on the next tick)', { decisionId: decision.id, error: msg });
+            return (await this.deps.store.update(decision.id, () => ({ postError: msg }))) ?? decision;
+        }
+    }
+    /**
+     * Where the card goes: the ticket's thread (created on first use), else the
+     * asker's current work destination, else a new thread in its team channel.
+     */
+    async placeFor(decision, identity, slack) {
+        if (decision.ticket) {
+            const t = decision.ticket;
+            const existing = await this.deps.threads.get(t.projectPath, t.id);
+            if (existing)
+                return { slackChannelId: existing.slackChannelId, threadTs: existing.threadTs, teamId: existing.teamId };
+            const channel = decision.teamId ? await this.deps.teamChannelOf(decision.teamId) : null;
+            if (!channel)
+                throw new DecisionError(409, `No Slack team channel for ${t.id}'s team — link the team to Slack first`);
+            const { ts } = await this.send(slack, identity, { channelId: channel, text: ticketThreadRootText(t) });
+            const thread = await this.deps.threads.set(t.projectPath, t.id, { slackChannelId: channel, threadTs: ts, ...(decision.teamId ? { teamId: decision.teamId } : {}) });
+            return { slackChannelId: thread.slackChannelId, threadTs: thread.threadTs, teamId: thread.teamId };
+        }
+        const work = await this.deps.workDestination?.(decision.asker).catch(() => null);
+        if (work?.slackChannelId)
+            return work;
+        const channel = decision.teamId ? await this.deps.teamChannelOf(decision.teamId) : null;
+        if (!channel)
+            throw new DecisionError(409, `No Slack place to ask in: ${decision.asker} has no team channel and no Slack conversation in hand`);
+        return { slackChannelId: channel, ...(decision.teamId ? { teamId: decision.teamId } : {}) };
+    }
+    /**
+     * Send as the agent's own bot; when Slack refuses that bot (not in the
+     * channel, revoked), fall back to the shared bot with the agent's name.
+     */
+    async send(slack, identity, message) {
+        const base = { ...message, skipChatV2Mirror: true };
+        if (identity.botToken) {
+            try {
+                return { ts: await slack.sendMessage({ ...base, botToken: identity.botToken }), ownBot: true };
+            }
+            catch (err) {
+                this.logger.warn("Agent's own bot could not post the decision card — using the shared bot", { channel: message.channelId, error: errText(err) });
+            }
+        }
+        const { botToken: _drop, ...shared } = identity;
+        return { ts: await slack.sendMessage({ ...base, ...shared }), ownBot: false };
+    }
+    // ---------------------------------------------------------------------------
+    // Answers
+    // ---------------------------------------------------------------------------
+    /**
+     * A Slack `block_actions` payload (Cloud relay, Socket Mode or the HTTP
+     * endpoint). Ignores anything that is not one of this instance's cards.
+     *
+     * @param payload - Slack payload
+     * @returns What happened
+     */
+    async handleInteraction(payload) {
+        const action = payload?.actions?.[0];
+        if (!action?.action_id?.startsWith(DECISION_CONSTANTS.ACTION_PREFIX))
+            return { handled: false, reason: 'not a decision action' };
+        const value = parseButtonValue(action.value);
+        if (!value)
+            return { handled: false, reason: 'unreadable button value' };
+        const self = this.deps.instanceId();
+        if (value.i && self && value.i !== self)
+            return { handled: false, reason: `card belongs to instance ${value.i}` };
+        const decision = await this.deps.store.get(value.d);
+        if (!decision)
+            return { handled: false, reason: `unknown decision ${value.d}` };
+        const channel = payload.container?.channel_id ?? payload.channel?.id;
+        const ts = payload.container?.message_ts ?? payload.message?.ts;
+        if (!decision.card || decision.card.slackChannelId !== channel || decision.card.messageTs !== ts) {
+            return { handled: false, reason: 'click is not on the stored card' };
+        }
+        const user = payload.user?.id ?? '';
+        if (!user || !this.deps.isOwner(user)) {
+            this.logger.info('Decision click by someone other than the owner — ignored', { decisionId: decision.id, user });
+            return { handled: false, reason: 'not the owner', decision };
+        }
+        if (decision.status !== 'open')
+            return { handled: false, reason: `already ${decision.status}`, decision };
+        const choice = value.o === 'remind' ? { kind: 'remind' } : { kind: 'option', key: value.o };
+        return this.apply(decision, choice, 'button', user);
+    }
+    /**
+     * A reaction on a card: ✅ default/first, ❌ the "no" option, ⏰ remind.
+     *
+     * @param event - `reaction_added` event
+     * @returns What happened
+     */
+    async handleReaction(event) {
+        const channel = event?.item?.channel;
+        const ts = event?.item?.ts;
+        if (!channel || !ts || !event.reaction)
+            return { handled: false, reason: 'not a message reaction' };
+        const decision = await this.deps.store.findByCard(channel, ts);
+        if (!decision)
+            return { handled: false, reason: 'not a decision card' };
+        if (decision.status !== 'open')
+            return { handled: false, reason: `already ${decision.status}`, decision };
+        if (!event.user || !this.deps.isOwner(event.user))
+            return { handled: false, reason: 'not the owner', decision };
+        const choice = choiceFromReaction(decision, event.reaction);
+        if (!choice)
+            return { handled: false, reason: `reaction :${event.reaction}: means nothing here`, decision };
+        return this.apply(decision, choice, 'reaction', event.user);
+    }
+    /**
+     * An owner reply in a card's thread. The newest open card in that thread
+     * takes it; words that match no option are passed to the asker verbatim.
+     *
+     * @param message - Inbound Slack message
+     * @returns What happened
+     */
+    async handleThreadReply(message) {
+        if (!message.threadTs || message.threadTs === message.ts)
+            return { handled: false, reason: 'not a thread reply' };
+        if (message.authorAgentSession)
+            return { handled: false, reason: 'written by an agent' };
+        if (!message.userId || !this.deps.isOwner(message.userId))
+            return { handled: false, reason: 'not the owner' };
+        const candidates = await this.deps.store.list((d) => d.status === 'open' &&
+            !!d.card &&
+            d.card.slackChannelId === message.channelId &&
+            (d.card.threadTs === message.threadTs || d.card.messageTs === message.threadTs));
+        const decision = candidates[0];
+        if (!decision)
+            return { handled: false, reason: 'no open card in this thread' };
+        const choice = choiceFromText(decision, message.text ?? '');
+        if (!choice)
+            return { handled: false, reason: 'empty reply', decision };
+        return this.apply(decision, choice, 'reply', message.userId);
+    }
+    /**
+     * The owner answered from the dashboard.
+     *
+     * @param id - Decision id
+     * @param optionKey - Option key (or label / number)
+     * @returns The resolved decision
+     * @throws DecisionError(404/409/400)
+     */
+    async chooseFromDashboard(id, optionKey) {
+        const decision = await this.requirePending(id);
+        const opt = decision.options.find((o) => o.key === optionKey) ?? decision.options.find((o) => o.label.toLowerCase() === String(optionKey).toLowerCase());
+        if (!opt)
+            throw new DecisionError(400, `"${optionKey}" is not an option of ${id} (${decision.options.map((o) => o.key).join(', ')})`);
+        const out = await this.apply(decision, { kind: 'option', key: opt.key }, 'dashboard', this.deps.ownerUserId?.() ?? undefined);
+        return out.decision ?? decision;
+    }
+    /**
+     * "Remind me tomorrow" from the dashboard.
+     *
+     * @param id - Decision id
+     * @returns The snoozed decision
+     */
+    async remindFromDashboard(id) {
+        const decision = await this.requirePending(id);
+        const out = await this.apply(decision, { kind: 'remind' }, 'dashboard', this.deps.ownerUserId?.() ?? undefined);
+        return out.decision ?? decision;
+    }
+    /**
+     * Withdraw open decisions (the asker no longer needs an answer, or the
+     * ticket's mark was cleared).
+     *
+     * @param filter - Which decisions
+     * @param note - Why (ticket log)
+     * @returns How many were withdrawn
+     */
+    async cancelWhere(filter, note) {
+        const open = await this.deps.store.list((d) => PENDING_DECISION_STATUSES.has(d.status) && filter(d));
+        for (const d of open) {
+            const done = await this.deps.store.update(d.id, (cur) => (PENDING_DECISION_STATUSES.has(cur.status) ? { status: 'cancelled', resolvedAt: this.now().toISOString() } : null));
+            if (!done)
+                continue;
+            await this.refreshCard(done);
+            this.logger.info('Owner decision withdrawn', { decisionId: d.id, note });
+        }
+        return open.length;
+    }
+    /**
+     * List decisions.
+     *
+     * @param which - `open` (open + parked) or `all`
+     * @returns Decisions, newest first
+     */
+    async list(which = 'open') {
+        const all = await this.deps.store.list(which === 'open' ? (d) => PENDING_DECISION_STATUSES.has(d.status) : undefined);
+        return all.slice(0, DECISION_CONSTANTS.MAX_LISTED);
+    }
+    /**
+     * One decision.
+     *
+     * @param id - Decision id
+     * @returns Decision or null
+     */
+    get(id) {
+        return this.deps.store.get(id);
+    }
+    async requirePending(id) {
+        const decision = await this.deps.store.get(id);
+        if (!decision)
+            throw new DecisionError(404, `Decision ${id} not found`);
+        if (!PENDING_DECISION_STATUSES.has(decision.status))
+            throw new DecisionError(409, `Decision ${id} is already ${decision.status}`);
+        return decision;
+    }
+    /**
+     * Apply a choice: resolve (or snooze), update the card, log the ticket,
+     * tell the asker, close the watchdog entry.
+     */
+    async apply(decision, choice, via, user) {
+        const now = this.now();
+        if (choice.kind === 'remind') {
+            const remindAt = tomorrowAt(now, DECISION_CONSTANTS.REMIND_HOUR_LOCAL);
+            const minDeadline = remindAt.getTime() + DECISION_CONSTANTS.REMIND_GRACE_MS;
+            const updated = await this.deps.store.update(decision.id, (cur) => PENDING_DECISION_STATUSES.has(cur.status)
+                ? {
+                    status: 'open',
+                    remindAt: remindAt.toISOString(),
+                    deadline: new Date(Math.max(Date.parse(cur.deadline), minDeadline)).toISOString(),
+                    // A parked sensitive ask that is snoozed gets its re-ask cycle back.
+                    reaskedAt: cur.status === 'parked' ? undefined : cur.reaskedAt,
+                }
+                : null);
+            if (!updated)
+                return { handled: false, reason: 'already settled', decision };
+            await this.refreshCard(updated);
+            if (updated.ticket)
+                await this.logTicket(updated, `owner decision ${updated.id}: remind tomorrow (${via})`, false);
+            this.logger.info('Owner decision snoozed to tomorrow', { decisionId: decision.id, via });
+            return { handled: true, reason: 'snoozed', decision: updated };
+        }
+        const patch = choice.kind === 'option'
+            ? { status: 'resolved', chosenKey: choice.key, answerText: undefined }
+            : { status: 'resolved', chosenKey: undefined, answerText: choice.text.slice(0, 2000) };
+        const resolved = await this.deps.store.update(decision.id, (cur) => PENDING_DECISION_STATUSES.has(cur.status)
+            ? { ...patch, answeredVia: via, ...(user ? { answeredBy: user } : {}), resolvedAt: now.toISOString(), remindAt: undefined }
+            : null);
+        if (!resolved)
+            return { handled: false, reason: 'already settled', decision };
+        await this.refreshCard(resolved);
+        const answer = resolved.chosenKey ? optionLabel(resolved, resolved.chosenKey) : `“${resolved.answerText}”`;
+        if (resolved.ticket)
+            await this.logTicket(resolved, `owner decision ${resolved.id}: ${answer} (${via})`, true);
+        await this.tellAsker(resolved, this.answerNote(resolved));
+        this.closeWatchdog(resolved);
+        this.logger.info('Owner decision resolved', { decisionId: resolved.id, via, chosen: resolved.chosenKey ?? 'text' });
+        return { handled: true, reason: 'resolved', decision: resolved };
+    }
+    /** The note the asker receives when the owner answered. */
+    answerNote(d) {
+        const where = this.whereLine(d);
+        const about = `for: "${d.question}"${d.ticket ? ` (ticket ${d.ticket.id})` : ''}`;
+        if (d.chosenKey) {
+            return `[DECISION ${d.id}] The owner chose "${optionLabel(d, d.chosenKey)}" ${about}. Act on it now.${where}`;
+        }
+        return `[DECISION ${d.id}] The owner answered in words ${about}: "${d.answerText ?? ''}". Read it as their decision and act on it; if it is genuinely unclear, ask once more with ask-owner.${where}`;
+    }
+    /** Where the asker's follow-up belongs. */
+    whereLine(d) {
+        if (!d.card)
+            return '';
+        const thread = d.card.threadTs ?? d.card.messageTs;
+        return ` Post any update in the card's thread (--thread ${d.card.slackChannelId}:${thread}).`;
+    }
+    // ---------------------------------------------------------------------------
+    // Deadlines and reminders
+    // ---------------------------------------------------------------------------
+    /**
+     * One pass: retry unposted cards, post due reminders, apply defaults at
+     * the deadline, re-ask / park sensitive asks, prune old decisions.
+     *
+     * @returns Ids acted on
+     */
+    async tick() {
+        if (this.ticking)
+            return [];
+        this.ticking = true;
+        const acted = [];
+        try {
+            const now = this.now();
+            for (const d of await this.deps.store.list((x) => x.status === 'open')) {
+                try {
+                    if (!d.card) {
+                        // A card Slack refused is retried every few minutes, not every tick.
+                        if (d.postError && now.getTime() - Date.parse(d.updatedAt) < DECISION_CONSTANTS.POST_RETRY_MS)
+                            continue;
+                        if ((await this.postCard(d)).card)
+                            acted.push(d.id);
+                        continue;
+                    }
+                    if (d.remindAt && Date.parse(d.remindAt) <= now.getTime()) {
+                        await this.remindNow(d);
+                        acted.push(d.id);
+                        continue;
+                    }
+                    if (Date.parse(d.deadline) > now.getTime())
+                        continue;
+                    if (d.sensitive) {
+                        if (await this.sensitiveStep(d, now))
+                            acted.push(d.id);
+                    }
+                    else if (await this.applyDefault(d, now)) {
+                        acted.push(d.id);
+                    }
+                }
+                catch (err) {
+                    this.logger.warn('Decision tick step failed', { decisionId: d.id, error: errText(err) });
+                }
+            }
+            await this.deps.store.prune().catch(() => 0);
+        }
+        finally {
+            this.ticking = false;
+        }
+        return acted;
+    }
+    /** Post the "Remind me tomorrow" reminder in the card's thread. */
+    async remindNow(d) {
+        const updated = await this.deps.store.update(d.id, (cur) => (cur.status === 'open' && cur.remindAt ? { remindAt: undefined } : null));
+        if (!updated)
+            return;
+        const owner = this.deps.ownerUserId?.();
+        await this.postInThread(updated, `${owner ? `<@${owner}> ` : ''}Reminder: ${updated.question} (answer on the card above)`);
+        await this.refreshCard(updated);
+    }
+    /** Non-sensitive deadline: apply the default (or say it keeps waiting). */
+    async applyDefault(d, now) {
+        const line = deadlineDefaultLine(d, now);
+        if (d.defaultKey === DECISION_CONSTANTS.WAIT_DEFAULT) {
+            if (d.deadlineNoticeAt)
+                return false;
+            const updated = await this.deps.store.update(d.id, (cur) => (cur.status === 'open' && !cur.deadlineNoticeAt ? { deadlineNoticeAt: now.toISOString() } : null));
+            if (!updated)
+                return false;
+            await this.postInThread(updated, line);
+            if (updated.ticket)
+                await this.logTicket(updated, `owner decision ${updated.id}: no answer by the deadline — still waiting`, false);
+            await this.tellAsker(updated, `[DECISION ${updated.id}] No answer by the deadline for: "${updated.question}". The default is to wait — keep this work parked until the owner answers.${this.whereLine(updated)}`);
+            return true;
+        }
+        const resolved = await this.deps.store.update(d.id, (cur) => cur.status === 'open' ? { status: 'defaulted', chosenKey: cur.defaultKey, answeredVia: 'deadline', resolvedAt: now.toISOString() } : null);
+        if (!resolved)
+            return false;
+        await this.refreshCard(resolved);
+        await this.postInThread(resolved, line);
+        if (resolved.ticket)
+            await this.logTicket(resolved, `owner decision ${resolved.id}: no answer — default "${defaultLabel(resolved)}" applied`, true);
+        await this.tellAsker(resolved, `[DECISION ${resolved.id}] No answer by the deadline for: "${resolved.question}"${resolved.ticket ? ` (ticket ${resolved.ticket.id})` : ''}. Going with the default: "${defaultLabel(resolved)}". Act on it now.${this.whereLine(resolved)}`);
+        this.closeWatchdog(resolved);
+        this.logger.info('Owner decision defaulted at the deadline', { decisionId: resolved.id, chosen: resolved.chosenKey });
+        return true;
+    }
+    /** Sensitive deadline: re-ask once after 24 h, then park. Never auto-applied. */
+    async sensitiveStep(d, now) {
+        if (!d.reaskedAt) {
+            const due = Math.max(Date.parse(d.deadline), Date.parse(d.createdAt) + DECISION_CONSTANTS.SENSITIVE_REASK_AFTER_MS);
+            if (now.getTime() < due)
+                return false;
+            const updated = await this.deps.store.update(d.id, (cur) => (cur.status === 'open' && !cur.reaskedAt ? { reaskedAt: now.toISOString() } : null));
+            if (!updated)
+                return false;
+            const owner = this.deps.ownerUserId?.();
+            await this.postInThread(updated, `${owner ? `<@${owner}> ` : ''}Still need your answer: ${updated.question} This needs your OK (${updated.sensitive}), so I'm not going ahead without it.`);
+            await this.refreshCard(updated);
+            this.logger.info('Sensitive owner decision re-asked', { decisionId: d.id });
+            return true;
+        }
+        if (now.getTime() < Date.parse(d.reaskedAt) + DECISION_CONSTANTS.SENSITIVE_PARK_AFTER_REASK_MS)
+            return false;
+        const parked = await this.deps.store.update(d.id, (cur) => (cur.status === 'open' ? { status: 'parked' } : null));
+        if (!parked)
+            return false;
+        await this.refreshCard(parked);
+        if (parked.ticket)
+            await this.logTicket(parked, `owner decision ${parked.id}: no answer after a re-ask — parked (sensitive: ${parked.sensitive})`, false);
+        await this.tellAsker(parked, `[DECISION ${parked.id}] No answer to: "${parked.question}" even after a re-ask. It needs the owner's OK (${parked.sensitive}), so it is PARKED: do not do it. Move on to other work; you will get a [DECISION] message if the owner answers.`);
+        this.logger.info('Sensitive owner decision parked', { decisionId: d.id });
+        return true;
+    }
+    // ---------------------------------------------------------------------------
+    // Slack helpers
+    // ---------------------------------------------------------------------------
+    /** Re-render the card for the decision's current state (with the posting bot's token). */
+    async refreshCard(d) {
+        const slack = this.deps.slack();
+        if (!d.card || !slack)
+            return;
+        const now = this.now();
+        const pending = d.status === 'open';
+        let ownerName;
+        if (!pending && d.answeredBy)
+            ownerName = await this.deps.userName?.(d.answeredBy).catch(() => undefined);
+        const blocks = pending ? renderOpenCard(d, this.deps.instanceId(), now) : renderSettledCard(d, ownerName, now);
+        const text = pending ? cardFallbackText(d) : `${cardFallbackText(d)} — ${settledLine(d, ownerName, now)}`;
+        const token = d.card.ownBot ? (await this.deps.identityOf(d.card.postedBy).catch(() => ({}))).botToken : undefined;
+        try {
+            await slack.updateMessage(d.card.slackChannelId, d.card.messageTs, text, blocks, token);
+        }
+        catch (err) {
+            this.logger.warn('Could not update the decision card', { decisionId: d.id, error: errText(err) });
+        }
+    }
+    /** Post a line in the card's thread, as the asker. */
+    async postInThread(d, text) {
+        const slack = this.deps.slack();
+        if (!d.card || !slack || !slack.isConnected())
+            return;
+        try {
+            const identity = await this.deps.identityOf(d.asker);
+            await this.send(slack, identity, { channelId: d.card.slackChannelId, text, threadTs: d.card.threadTs ?? d.card.messageTs });
+        }
+        catch (err) {
+            this.logger.warn('Could not post in the decision thread', { decisionId: d.id, error: errText(err) });
+        }
+    }
+    async logTicket(d, line, settled) {
+        if (!d.ticket)
+            return;
+        let clear = false;
+        if (settled) {
+            const others = await this.deps.store.list((x) => x.id !== d.id && PENDING_DECISION_STATUSES.has(x.status) && x.ticket?.projectPath === d.ticket?.projectPath && x.ticket?.id === d.ticket?.id);
+            clear = others.length === 0;
+        }
+        await this.deps.logTicket(d.ticket, line, clear).catch((err) => this.logger.warn('Could not log the decision on the ticket', { decisionId: d.id, error: errText(err) }));
+    }
+    async tellAsker(d, text) {
+        const ok = await this.deps.deliverToAgent(d.asker, text).catch(() => false);
+        if (!ok)
+            this.logger.warn('Could not deliver the decision to the asking agent', { decisionId: d.id, asker: d.asker });
+        // The orchestrator asked on the owner's behalf for a ticket it does not own: tell it too.
+        if (d.requestedBy !== d.asker && d.requestedBy === ORCHESTRATOR_SESSION_NAME) {
+            await this.deps.deliverToAgent(d.requestedBy, text).catch(() => false);
+        }
+    }
+    closeWatchdog(d) {
+        if (!d.card || !this.deps.closeWatchdog)
+            return;
+        try {
+            this.deps.closeWatchdog(d.asker, d.card.slackChannelId, d.card.threadTs ?? d.card.messageTs);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+/**
+ * Message of an unknown error.
+ *
+ * @param err - Thrown value
+ * @returns Text
+ */
+function errText(err) {
+    if (err && typeof err === 'object') {
+        const data = err.data;
+        if (typeof data?.error === 'string')
+            return data.error;
+    }
+    return err instanceof Error ? err.message : String(err);
+}
+/** Re-exported for the deadline line in the dashboard/API. */
+export { formatWhen };
+//# sourceMappingURL=decision.service.js.map