메뉴
Copy passed Messages rows into today's Queue tab (ranked, capped at daily-N, both DM messages + LinkedIn links), render the self-contained HTML cockpit from that tab, then run the STATUS paste-back loop. User-invoked and side-effecting — never auto-run.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
Harvest LinkedIn-reachable buyer and champion contacts for the head-of-queue companies in the workbook, then build a $0 keyless per-company buying map (org roles, reporting edges, approach order) before any paid call, then reveal verified emails ONLY for the head of queue via the Apollo to Hunter to None waterfall. Contact harvest runs through LinkedIn-dork subagents that trust link titles and ignore SERP prose and return rows as text; the main session writes the People tab. Reveal is budget-gated and ask-first, logs every credit to the Budget tab, and never guesses an email. Run after targets has populated and tiered Companies, once per daily slice, before drafting messages.
Draft two-message DM packs (connect note + post-accept DM, email variant only on a verified email) for People rows that lack messages, write them to the workbook's Messages tab with claims and dial columns, fact-check every claim at the caution dial, and set STATUS per the dial gate. Use when the user asks to draft outreach, write messages, fact-check drafts, or re-check rows they edited in the sheet.
The Galois GTM setup interview. Creates the campaign folder and workbook (~/GaloisGTM/<campaign>/gtm.xlsx), then builds and confirms galois.profile.yaml beside it (ICP plus confirmed adjacent profiles, per-segment discovery plan, personas, voice, caution dial, channels, budgets). Use when the user says "set up galois" / "set up galois-gtm", "new campaign", "interview me", "onboard me", drops a URL or doc to profile from, or when any galois-gtm skill finds no confirmed galois.profile.yaml next to the workbook. Also handles single-field tunes and drift check-ins.
Discover the day's target companies straight into the workbook's Companies tab and tier them into a trigger-sorted slice of 10-20. Run the profile's discovery plan — gate-matched lanes only: web-search and hiring-signal discovery for any vertical, registry pulls (openFDA / USAspending / SEC EDGAR) solely when the ICP trait matches, plus any CSV the human dropped in the folder — dedupe in the Companies tab itself, apply the 2+ lane multi-signal gate as a tier-A proposal, rank by trigger recency, then subagent-tier the single-signal residue (subagents RETURN rows, the main session writes). Use to build or refresh the target list before /galois-enrich.
The 5-minute morning GTM ritual — read the workbook's Budget/Log, Queue, and Companies tabs, inline a short digest (new triggers, queue state, invites vs cap, acceptance %, budget), append the wave-log line, then offer exactly three actions.
SOC 직업 분류 기준
| name | queue |
| description | Copy passed Messages rows into today's Queue tab (ranked, capped at daily-N, both DM messages + LinkedIn links), render the self-contained HTML cockpit from that tab, then run the STATUS paste-back loop. User-invoked and side-effecting — never auto-run. |
| disable-model-invocation | true |
| argument-hint | [daily-n] |
If a structured question tool is available (
AskUserQuestionon Claude Code — one question per call;ask_user_questionon Codex — at most 3 per turn, 2–3 options plus free text, pause the auto-resolve countdown), use it. Otherwise restate each question verbatim, then lettered options with the recommended one marked, and accept a letter, "recommended", or the user's own answer. Never present options without restating the question (the spec-kit #1147 lesson). On Claude Desktop, at most 2 questions per message.
The last stage, and pure plumbing: no research, no drafting, no LLM calls, no subagents. You read the ready rows the /messages wave already drafted, fact-checked, and gated; you copy the ones that clear selection into the Queue tab; you render the HTML cockpit from that tab; you run the STATUS paste-back loop. The pass/block decision is not yours — it already happened at /messages (a blocked Messages row never reaches you). You are single-threaded over the workbook; nothing here fans out.
The workbook is the state: ~/GaloisGTM/<campaign>/gtm.xlsx. Locate it — if this skill got a path argument use it; else if exactly one folder exists under ~/GaloisGTM/ use that campaign; else ask which campaign (structured question per the preamble). On Claude Code / Codex read and write it with inline python3 + openpyxl (python3 -c "import openpyxl" || pip install --user openpyxl once per session; CSV fallback = <campaign>/sheets/*.csv, same headers). On Desktop use the native xlsx tooling on the uploaded file and return the updated file at the end.
gtm.xlsx (and no galois.profile.yaml beside it)? The campaign was never set up — stop and send the user to /galois-setup.ready Messages rows exist. Read the Messages tab; keep rows with STATUS == ready (the passed / green state — draft, checked, and blocked are not eligible). If none are ready: the pipeline has not produced sendable drafts yet — point the user to /galois-targets → /galois-enrich → /galois-messages, then come back. Do not invent rows.Before your first write, say: "If gtm.xlsx is open in Excel/Numbers, close it now — Excel's next save would silently overwrite what I'm about to write."
Load, in the main session only, the tabs you need:
STATUS == ready rows: person, company, channel, subject, body, claims, verdict, dial.SELECT, linkedin, email, email_source, per person.tier/TIER, rank, signals (for trigger text + recency), per company.key, scope (domain / person / email).python3 - <<'EOF'
import openpyxl, os
p = os.path.expanduser("~/GaloisGTM/<campaign>/gtm.xlsx")
wb = openpyxl.load_workbook(p, data_only=True)
def rows(name):
ws = wb[name]; hdr = [c.value for c in ws[1]]
return [dict(zip(hdr, [c.value for c in r])) for r in ws.iter_rows(min_row=2)]
msgs = [m for m in rows("Messages") if (m.get("STATUS") or "").strip() == "ready"]
people = {(r["company"], r["name"]): r for r in rows("People")}
comps = {c["name"]: c for c in rows("Companies")}
supp = rows("Suppressed")
# ... join + rank in Python below ...
EOF
Work over the ready Messages rows joined to their People and Companies rows:
domain, or email matches a Suppressed key at the matching scope (a domain-scope key with no dot is a company name — match it against the normalized company name). Suppressed keys never enter the Queue — no exceptions.SELECT == N → skip the person entirely. SELECT == Y → force-include (ahead of rank). Blank → the machine decides by rank.SELECT=Y) contacts float to the top. Effective tier = TIER if non-blank else tier. Trigger recency comes from the dated signals on the Companies row.[daily-n] argument). N counts contacts, not rows — a person's two-message pack is one contact.ready message the contact has: li_note + li_dm are the two-message DM pack (two rows); an email row rides along only if the People row carries a verified email and email_source — no verified email means DM-only, never a guessed address.ready rows, at dial 0–1 never copy a row whose verdict is not clean (any FALSE / UNVERIFIABLE claim). Finding one here means an upstream bug — leave it out and name it in your outro; do not talk past the gate.Append today's selection to the Queue tab (headers are the contract: date | person | company | channel | linkedin | subject | body | dial | STATUS | STATUS_NOTE), one row per message:
date = today; person, company, channel, subject, body, dial copied through; linkedin = the People row's link (or linkedin.com/in/<slug>); STATUS and STATUS_NOTE blank (human-owned).(date=today, person, company, channel) row already exists from an earlier run today, preserve its STATUS / STATUS_NOTE and refresh only the lowercase cells.Write with the standard discipline — one-generation undo, atomic replace:
python3 - <<'EOF'
import openpyxl, os, shutil
p = os.path.expanduser("~/GaloisGTM/<campaign>/gtm.xlsx")
shutil.copyfile(p, p.replace("gtm.xlsx", "gtm.prev.xlsx"))
wb = openpyxl.load_workbook(p)
q = wb["Queue"]
# append/refresh today's rows, preserving any non-blank STATUS/STATUS_NOTE
tmp = p.replace("gtm.xlsx", "gtm.tmp.xlsx")
wb.save(tmp); os.replace(tmp, p)
EOF
Then write the self-contained HTML cockpit directly from today's Queue rows to ~/GaloisGTM/<campaign>/queue-YYYY-MM-DD.html (Write tool, or Desktop file output). It is a rendering of the Queue tab — it invents nothing. It is beloved; keep it. Hard requirements:
caution: flags read from verdict.li_note connect note with a live character badge (NNN/300, warns over 300) and a [Copy connect note] button; the post-accept li_dm with [Copy post-accept DM]. email rows render the body with the opt-out line appended and a copy button.linkedin.com/in/<slug> — the human clicks Connect/Message and pastes. Two clicks, zero automation; no link ever prefills a DM.( ) sent ( ) accepted ( ) replied ( ) skip: reason ▾, persisted to localStorage, each group carrying a stable data-key="person|company|channel".{key, status, note} — for paste-back (step 5).date | person | company | channel | linkedin | subject | body | dial | STATUS | STATUS_NOTE), with STATUS/STATUS_NOTE read live from that card's radios/note field at click time; Excel-quote any field containing a tab, newline, or double quote (wrap in ", double inner quotes) so a paste lands one field per cell, multi-line bodies included.The beloved layout, for reference:
┌ Today's DM queue — Wed · 15 remaining · invites this week: 34/80 · acceptance 44% · dial 1 ┐
│ Maria Chen — Dir. Quality, Acme Surgical (Tier A) │
│ trigger: 510(k) K261234 cleared Jun 12 (21d) flags: none │
│ [Open profile ↗] [Copy connect note 278/300] [Copy post-accept DM] │
│ ( ) sent ( ) accepted ( ) replied ( ) skip: reason ▾ │
└────────────────────────────────────────────────────────────────────────────────────────────┘
Give the user the cockpit's absolute path when it lands.
The Queue tab's STATUS / STATUS_NOTE marks are the ledger (STATUS ∈ sent / accepted / replied / skip / bounced). Two equal paths write those same cells:
sent / accepted / replied / skip / bounced straight into the Queue tab's STATUS column (reason in STATUS_NOTE). Editing the sheet is the command — the next wave and /galois-daily read whatever is there.STATUS/STATUS_NOTE columns — paste them over the matching rows in the Queue tab in Excel/Sheets; same effect as typing the marks.{key: "person|company|channel", status, note} to today's Queue row on (date=today, person, company, channel) and write STATUS / STATUS_NOTE for it — atomic tmp+replace, and never overwrite a non-blank human mark with a blank.Either path is what makes tomorrow's queue, the invite pacing, and the acceptance meter reflect what actually happened.
The human sends every message. There is no send code path anywhere in this tooling. Period. The queue is deep-link + clipboard + a human click. Pacing numbers are advisory; the sender is the rail. Before anything goes out, the dial level and any flags are visible on every card — the human sees the accepted risk first. Never paste queue output into an automation tool: that burns the account the whole motion depends on.
Wave outro (mandatory): "Wave done: 15 contacts queued (28 message rows) — cockpit at ~/GaloisGTM//queue-2026-07-05.html; mark STATUS in the Queue tab or the cockpit, and the next wave reads whatever is there."
Optional: deterministic CLI. Power users may instead run the old galois queue build/export engine from the repo's src/ appendix; no skill requires it, and the workbook flow above is complete without it.