sparkecoder 0.1.126 → 0.1.127

package/dist/server/index.js

@@ -4239,8 +4239,10 @@ async function loadAgentsMd(agentsMdPath) {
 }
 async function loadSkillContent(skillName, directories) {
   const allSkills = await loadAllSkills(directories);
+  const normalize2 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const wanted = normalize2(skillName);
   const skill = allSkills.find(
-    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+    (s) => normalize2(s.name) === wanted || normalize2(basename(s.filePath, extname4(s.filePath))) === wanted
   );
   if (!skill) {
     return null;
@@ -7038,7 +7040,7 @@ Every user-message you see is tagged at the front with a channel pill describing
 Pill formats:
 
 - \`[WEB] ...\` \u2014 typed in the web dashboard. Your assistant text streams back automatically. No tool call needed.
-- \`[SLACK channel=C0123 thread=1700000000.001 user=U0123] ...\` \u2014 a Slack mention or DM. To reply: \`messenger({action:'post', channel:'slack', to:'C0123', threadTs:'1700000000.001', text:'...'})\`. **Always set \`threadTs\`** so the reply lands in the same thread.
+- \`[SLACK channel=C0123 thread=1700000000.001 user=Ryan Trattner <@U0123> (ryan@example.com)] ...\` \u2014 a Slack mention or DM. To reply: \`messenger({action:'post', channel:'slack', to:'C0123', threadTs:'1700000000.001', text:'...'})\`. **Always set \`threadTs\`** so the reply lands in the same thread. The \`user=\` field is enriched in-place: when the bot has the right scopes you get \`<Name> <@U_ID> (email)\`; if scopes are missing you may see just the raw id \u2014 that's not an error, just less context. Any \`<@U\u2026>\` mentions inside the message text are similarly normalized to \`<Name> <@U_ID>\` so you can immediately tell who's being addressed.
 - \`[SYSTEM worker.completed worker-name] ...\` \u2014 a worker you spawned finished. Look back at the conversation: where did the request originate?
   - If the original request was \`[WEB]\`, a normal text reply is enough (the user is watching).
   - If it was \`[SLACK ...]\`, post the result to that Slack thread via \`messenger\`.
@@ -7058,6 +7060,48 @@ If \`messenger({action:'post', ...})\` returns \`{ok:false, error:'...'}\` (e.g.
 **Never silently swallow a delivery failure.**
 </delivery_failures>
 
+<reaching_specific_people>
+
+When a request needs a *specific human's attention* (e.g. "ask Ryan to review this", "let Sarah know the deploy is done", "wait for Charlie's OK before merging") \u2014 don't just reply into thin air, actually surface it to that person. Two mechanisms, in order of preference:
+
+**1. @-ping them in a Slack channel they're already in (the cheap path)**
+
+If you know the person's Slack user id and the conversation has a relevant channel/thread, include a literal mention token in the message text. Slack renders \`<@U0123>\` as a clickable @-mention and pushes a notification to that user.
+
+\`\`\`
+messenger({
+  action: 'post', channel: 'slack',
+  to: 'C0B5CESSBGD', threadTs: '1700000000.001',
+  text: '<@U05C6RWBDPC> heads up \u2014 the deploy hit a flaky test, can you check?'
+})
+\`\`\`
+
+You already have the user id from inbound \`[SLACK ... user=U0123]\` pills. If multiple people are involved in a thread, you've seen their ids in the recent messages \u2014 use those. **The mention must be wrapped in \`<@...>\` \u2014 bare \`@username\` does NOT notify.**
+
+**2. DM them directly (when channel context is missing OR you only know their email)**
+
+For "DM Alice" / "shoot Bob a note" / pinging someone not in the current thread, use the **\`slack-messaging\` skill** \u2014 load it first with \`load_skill slack-messaging\`. It documents the lookup recipe (\`users.lookupByEmail\` \u2192 user id \u2192 \`messenger\` with the user id as \`to\`). Slack auto-opens the DM; no extra step.
+
+Quick form (when you've already loaded the skill earlier in the turn): look up the user id by email via the Slack API, then \`messenger({action:'post', channel:'slack', to:'<U_ID>', text:'...'})\`. No \`threadTs\` for DMs \u2014 they're standalone.
+
+**When to use which**
+
+| Situation | Use |
+|---|---|
+| Inbound Slack thread + you know the user is in it | ping with \`<@U\u2026>\` in the existing thread |
+| Need them but they're not in this channel/thread | DM (skill) |
+| Have only their email, not their id | DM (skill \u2014 it looks up the id) |
+| Need a broadcast-style heads-up | ping in their team's channel |
+| Sensitive / 1:1 conversation | always DM, never ping in a shared channel |
+
+**Don'ts**
+
+- Don't @-mention everyone in a channel ("FYI" pings \u2014 leave that to humans).
+- Don't ping AND DM the same person for the same thing \u2014 pick one.
+- Don't fabricate user ids or emails. If you don't know how to reach them, ask the requester ("which Sarah?") instead of guessing.
+- Don't ping in a thread the person hasn't shown up in unless the asker explicitly named them \u2014 surprise pings are annoying.
+</reaching_specific_people>
+
 <hard_rules>
 
 - Avoid direct workspace work. Do not directly edit product code, run builds, or perform substantive implementation yourself; spawn workers for that.
@@ -7978,7 +8022,12 @@ function load() {
     const now = Date.now();
     for (const [id, e] of Object.entries(parsed.users || {})) {
       if (e && typeof e.expiresAt === "number" && e.expiresAt > now) {
-        userMap.set(id, { name: e.name ?? null, expiresAt: e.expiresAt });
+        userMap.set(id, {
+          name: e.name ?? null,
+          realName: e.realName ?? null,
+          email: e.email ?? null,
+          expiresAt: e.expiresAt
+        });
       }
     }
     for (const [key2, e] of Object.entries(parsed.threads || {})) {
@@ -8173,7 +8222,7 @@ function getSlackAllowlistPolicy() {
     return { allowedUsers: [], allowedChannels: [], allowDmsFromAnyone: true };
   }
 }
-async function fetchSlackUserName(userId) {
+async function fetchSlackUserInfo(userId) {
   const token = getSlackBotToken();
   if (!token) return null;
   try {
@@ -8187,31 +8236,45 @@ async function fetchSlackUserName(userId) {
     }
     const profile = data.user?.profile || {};
     const name = profile.display_name_normalized || profile.display_name || profile.real_name_normalized || profile.real_name || data.user?.real_name || data.user?.name || null;
-    return name ? String(name) : null;
+    const realName = profile.real_name_normalized || profile.real_name || data.user?.real_name || null;
+    const email = profile.email || null;
+    return {
+      name: name ? String(name) : null,
+      realName: realName ? String(realName) : null,
+      email: email ? String(email) : null
+    };
   } catch (err) {
     console.warn(`[slack] users.info(${userId}) error:`, err?.message || err);
     return null;
   }
 }
-async function resolveSlackUserName(userId) {
+async function resolveSlackUserInfo(userId) {
   if (!userId) return null;
   const now = Date.now();
   const hit = getCachedUserName(userId);
-  if (hit && hit.expiresAt > now) return hit.name;
+  if (hit && hit.expiresAt > now) {
+    return { name: hit.name, realName: hit.realName ?? null, email: hit.email ?? null };
+  }
   const inflight = userInflight.get(userId);
   if (inflight) return inflight;
   const p = (async () => {
-    const name = await fetchSlackUserName(userId);
+    const info = await fetchSlackUserInfo(userId);
     setCachedUserName(userId, {
-      name,
-      expiresAt: now + (name ? USER_TTL_MS : USER_FAIL_TTL_MS)
+      name: info?.name ?? null,
+      realName: info?.realName ?? null,
+      email: info?.email ?? null,
+      expiresAt: now + (info?.name ? USER_TTL_MS : USER_FAIL_TTL_MS)
     });
     userInflight.delete(userId);
-    return name;
+    return info;
   })();
   userInflight.set(userId, p);
   return p;
 }
+async function resolveSlackUserName(userId) {
+  const info = await resolveSlackUserInfo(userId);
+  return info?.name ?? null;
+}
 async function normalizeSlackMentions(text) {
   if (!text) return text;
   const userMentionRe = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/g;
@@ -8444,6 +8507,13 @@ var init_slack = __esm({
 });
 
 // src/integrations/channels/system.ts
+var system_exports = {};
+__export(system_exports, {
+  systemChannel: () => systemChannel,
+  workerCompletedEvent: () => workerCompletedEvent,
+  workerFailedEvent: () => workerFailedEvent,
+  workerQuestionEvent: () => workerQuestionEvent
+});
 function workerCompletedEvent(workerId, workerName, summary) {
   const ref = { channel: "system", kind: "worker.completed", workerId, workerName };
   return {
@@ -9431,6 +9501,14 @@ var init_pending_input = __esm({
 });
 
 // src/orchestrator/inbox.ts
+var inbox_exports = {};
+__export(inbox_exports, {
+  clearInbox: () => clearInbox,
+  flush: () => flush,
+  peekInbox: () => peekInbox,
+  pushToInbox: () => pushToInbox,
+  setFlushHandler: () => setFlushHandler
+});
 function setFlushHandler(fn) {
   flushHandler = fn;
 }
@@ -9476,6 +9554,18 @@ async function flush(sessionId) {
     console.error("[orchestrator-inbox] flush handler threw:", err?.message || err);
   }
 }
+function peekInbox(sessionId) {
+  return inboxes.get(sessionId)?.pending.slice() ?? [];
+}
+function clearInbox(sessionId) {
+  const e = inboxes.get(sessionId);
+  if (!e) return;
+  if (e.timer) {
+    clearTimeout(e.timer);
+    e.timer = void 0;
+  }
+  e.pending.length = 0;
+}
 var inboxes, FLUSH_DEBOUNCE_MS, flushHandler;
 var init_inbox = __esm({
   "src/orchestrator/inbox.ts"() {
@@ -14119,6 +14209,18 @@ tasks.post(
                 data: { status: "failed", error: errorMsg }
               });
             }
+            if (body.orchestratorSessionId) {
+              try {
+                const { pushToInbox: pushToInbox2 } = await Promise.resolve().then(() => (init_inbox(), inbox_exports));
+                const { workerFailedEvent: workerFailedEvent2 } = await Promise.resolve().then(() => (init_system(), system_exports));
+                pushToInbox2(
+                  body.orchestratorSessionId,
+                  workerFailedEvent2(taskId, body.name || "worker", `(uncaught) ${errorMsg}`)
+                );
+              } catch (notifyErr) {
+                console.error(`[TASK] failed to notify orchestrator of crash:`, notifyErr?.message || notifyErr);
+              }
+            }
           }
         } finally {
           await writeSSE("[DONE]");
@@ -14368,12 +14470,11 @@ slack.post("/events", async (c) => {
       if (orchestratorId) {
         inbound.content = await normalizeSlackMentions(inbound.content);
         if (ev.user) {
-          const speakerName = await resolveSlackUserName(ev.user);
-          if (speakerName) {
-            inbound.content = inbound.content.replace(
-              `user=${ev.user}`,
-              `user=${speakerName} <@${ev.user}>`
-            );
+          const info = await resolveSlackUserInfo(ev.user);
+          if (info?.name) {
+            const emailSuffix = info.email ? ` (${info.email})` : "";
+            const enriched = `user=${info.name} <@${ev.user}>${emailSuffix}`;
+            inbound.content = inbound.content.replace(`user=${ev.user}`, () => enriched);
           }
         }
         pushToInbox(orchestratorId, inbound);