@method-ai-hq/sdk 0.0.0-stage → 0.14.3

package/dist/packages/sdk/examples/outbound-management/README.md

@@ -0,0 +1,119 @@
+# Manage daily outbound
+
+Each run reads email, finds prospects in Happenstance, checks their company and
+LinkedIn pages, updates the CRM, and writes today's tasks with outreach drafts.
+Messages stay unsent until you review and act on the tasks.
+
+## Steps
+
+| Step | Type | Output |
+| --- | --- | --- |
+| `read_crm` | run | target settings, contacts, resolved message IDs, CRM hash |
+| `read_email` | agent, browser | `messages`, `email_search` |
+| `find_prospects` | agent, browser | `prospects`, `prospect_search` |
+| `enrich` | agent, browser, `each` prospect | `enrichment` for each prospect |
+| `update_contacts` | call | `updated_contacts`, `resolutions` |
+| `draft_tasks` | call | `day_tasks` |
+| `save_day` | run, changes `state.crm` | `tasks.md`, `receipt.json` |
+
+Each model step does one task. The shape of each output is declared in `out`, so
+the prompts say only what to do and what to leave empty when a source does not
+have the answer.
+
+The `draft_tasks` prompt shows two tasks written the way they should be, for
+contacts that are not in the CRM: a reply to a pricing question and an
+introduction request. Replace them with two drafts that you sent and liked.
+
+The three browser steps accept the `untrusted_content_can_act` warning: each
+agent reads pages with a signed-in browser that could also send, and the
+`accept:` line on each step gives the reason to keep it. Nothing is sent until
+you review the tasks.
+
+## Sources
+
+- **Email:** opens your mailbox in the browser and reads received and sent
+  messages for the campaign. Saves message IDs and thread links with the CRM.
+- **Happenstance:** searches your connected network for people who fit your
+  target customer, including introduction paths. See its
+  [people search guide](https://happenstance.ai/guides/ai-people-search).
+- **Company websites and LinkedIn:** checks roles, company activity, and the
+  reason your offer fits. Saves page links and the facts read there. This uses
+  the existing browser and does not require a separate enrichment subscription.
+
+Each browser step has a check. It stops the run if the agent reports blocked
+access or returns a record without its link. A complete search may return no
+matches. Checks require source records; they do not prove that the agent found
+every email or that every source is accurate.
+
+## Set up and run
+
+Run from this folder. Copy the empty starter CRM once to set up the account.
+Set `target.customer`, `target.offer`, `target.new_prospects_per_day`, and
+`target.mailbox_url` for your business. The starter uses Gmail; replace its URL
+with your webmail URL if needed. Use the intended signed-in account.
+
+```sh
+mkdir -p work/crm
+cp starter/crm.json work/crm/crm.json
+method validate outbound.method
+method publish outbound.method --reason "First version"   # prints the Method ID
+python3 - <<'PY' > work/state.json
+import json
+from pathlib import Path
+print(json.dumps({'crm': Path('work/crm/crm.json').read_text()}))
+PY
+chmod 600 work/state.json
+method state METHOD_ID --enable --file work/state.json
+method run outbound.method --inputs inputs.json
+```
+
+Use the Method ID that `publish` printed; it is also the `id:` line in the file. Set `day` and `from_date` in `inputs.json` before
+each run. Use an overlap with the last run so late replies are included.
+Method connects the browser. Follow its setup request
+if email, Happenstance, or LinkedIn needs sign-in.
+
+Open the returned `tasks.md` and `receipt.json`. Updates are saved in shared
+Method account state. The setup file is a snapshot, not the current CRM. Run the saved Method daily
+or use your scheduler; this Method does not create a schedule itself.
+
+## Saved state
+
+The CRM keeps contacts, owner notes, message history, introduction paths, and
+daily plans. Already resolved email IDs are skipped. Unclear senders remain for
+review. Customers and opt-outs stay out of outreach tasks.
+
+A checked plan returns a replacement for `state.crm`. Method accepts that state
+only after the save check passes. Shared account state uses revision checks, so local
+and production runs use one current CRM. If the CRM changed during
+research, the save stops. Repeating the same save does not repeat its updates.
+The receipt records the saved state hash. Keep shared state enabled for normal use.
+
+`update_contacts` and `draft_tasks` each have a check that `save_day` runs again
+before it changes the CRM. The research notes for the day are the notes from the
+email search, the Happenstance search, and the pages that could not be opened.
+
+## Production
+
+Publish the Method and run it from an app with `method connect APP_FOLDER`, from
+`method worker`, or on Method Cloud (`method publish --cloud`). Production runs use
+the same account CRM; they do not need a writable local folder. Publishing does
+not schedule or send outreach.
+
+## Files and checks
+
+- `outbound.method`: read CRM, read email, find and enrich prospects, update contacts, draft tasks, save.
+- `crm.py` and entry scripts: state reads, source checks (`check_sources.py email|prospects|enrichment`),
+  contact and task checks (`check_plan.py contacts|tasks`), state replacements.
+- `starter/crm.json`: empty CRM with editable target settings.
+- `inputs.json`: email date range and date to plan.
+
+Fictional records are only in `fixtures/` for local state
+tests. They are not inputs to this Method. The tests cover two-day history,
+repeated saves, stale writes, owner notes, opt-outs, unclear senders, and blocked
+sources. A live run is still needed to check signed-in access and research quality.
+
+Run the state tests offline with `python3 -m unittest crm_test.py`.
+`fixtures/observations.json` and `fixtures/plan.json` hold step outputs for the
+fictional first day. `fixtures/tasks.md`, `fixtures/receipt.json`, and
+`fixtures/state.json` are the outputs that `save_day` makes from them, not a live
+account run. A test checks that they are current.

package/dist/packages/sdk/examples/outbound-management/TASK.md

@@ -0,0 +1,5 @@
+# Request
+
+Read campaign email and prospect sources each day. Keep the CRM current, preserve
+owner notes and opt-outs, and prepare due tasks with outreach drafts for review.
+Keep messages unsent. Reuse saved state on the next run.

package/dist/packages/sdk/examples/outbound-management/check_plan.py

@@ -0,0 +1,16 @@
+import json
+import sys
+from crm import check_contacts, check_tasks
+args = json.load(sys.stdin)
+given, out = args['inputs'], args['outputs']
+try:
+    if sys.argv[1] == 'contacts':
+        check_contacts(given['contacts'], given['resolved'], given['messages'], given['enrichment'],
+            out['updated_contacts'], out['resolutions'])
+    else:
+        contacts = {c['id']: c for c in given['contacts'] + given['updated_contacts']}
+        check_tasks(given['day'], contacts, out['day_tasks'])
+    result = {'status': 'pass', 'reason': 'The ' + sys.argv[1] + ' are valid.', 'evidence': []}
+except (ValueError, KeyError, TypeError) as error:
+    result = {'status': 'fail', 'reason': str(error), 'evidence': []}
+print(json.dumps(result))

package/dist/packages/sdk/examples/outbound-management/check_sources.py

@@ -0,0 +1,14 @@
+import json
+import sys
+from crm import check_email, check_enrichment, check_search
+args = json.load(sys.stdin)
+out = args['outputs']
+checks = {'email': lambda: check_email(out['email_search'], out['messages']),
+    'prospects': lambda: check_search(out['prospect_search'], 'happenstance'),
+    'enrichment': lambda: check_enrichment(out['enrichment'])}
+try:
+    checks[sys.argv[1]]()
+    result = {'status': 'pass', 'reason': 'Source records are complete.', 'evidence': []}
+except (ValueError, KeyError, TypeError) as error:
+    result = {'status': 'fail', 'reason': str(error), 'evidence': []}
+print(json.dumps(result))

package/dist/packages/sdk/examples/outbound-management/crm.py

@@ -0,0 +1,153 @@
+"""Read the CRM, check each step's records, and save the day's plan."""
+import datetime
+import hashlib
+import json
+import os
+from pathlib import Path
+from urllib.parse import urlparse
+
+STATUSES = ('new', 'contacted', 'replied', 'qualified', 'meeting', 'customer', 'closed', 'opted_out')
+FIELDS = ('id', 'name', 'email', 'company', 'role', 'fit', 'sources', 'status',
+    'next_action', 'next_action_date', 'introduction_path')
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def read(args):
+    if datetime.date.fromisoformat(args['from_date']) > datetime.date.fromisoformat(args['day']):
+        raise ValueError('Email start date is after the run date')
+    crm = json.loads(args['crm'])
+    return {'target': crm['target'], 'contacts': crm['contacts'],
+        'resolved': [m['id'] for m in crm['messages'] if m['contact_id']],
+        'crm_sha256': digest(args['crm'].encode())}
+
+
+def check_search(search, name):
+    if search['status'] != 'complete':
+        raise ValueError('Source access is incomplete: ' + name)
+
+
+def check_email(search, messages):
+    check_search(search, 'email')
+    ids = set()
+    for m in messages:
+        if not m['id'] or m['id'] in ids:
+            raise ValueError('Duplicate or empty email ID')
+        ids.add(m['id'])
+        if m['direction'] not in ('received', 'sent') or not m['text']:
+            raise ValueError('Invalid email record')
+        datetime.datetime.fromisoformat(m['at'].replace('Z', '+00:00'))
+        if urlparse(m['url']).scheme != 'https':
+            raise ValueError('Email needs a source link')
+
+
+def check_enrichment(enrichment):
+    if not enrichment['sources']:
+        raise ValueError('Prospect needs enrichment sources')
+    for source in enrichment['sources']:
+        if urlparse(source['url']).scheme != 'https' or not source['facts']:
+            raise ValueError('Enrichment needs a page link and facts')
+
+
+def check_contacts(contacts, resolved, messages, enrichment, updated, resolutions):
+    """Return all contacts by ID after the updates, keeping owner notes."""
+    old = {c['id']: c for c in contacts}
+    collected = {m['url'] for m in messages} | {s['url'] for e in enrichment for s in e['sources']}
+    collected |= {u for c in contacts for u in c['sources']}
+    emails = {c['email'].lower(): c['id'] for c in contacts if c['email']}
+    merged, seen = dict(old), set()
+    for c in updated:
+        if not c['id'] or c['id'] in seen:
+            raise ValueError('Invalid or duplicate contact')
+        seen.add(c['id'])
+        if c['status'] not in STATUSES:
+            raise ValueError('Invalid contact status')
+        if c['next_action_date']:
+            datetime.date.fromisoformat(c['next_action_date'])
+        if any(url not in collected for url in c['sources']):
+            raise ValueError('Contact source was not collected')
+        if c['id'] not in old and (not c['sources'] or not c['fit']):
+            raise ValueError('New prospects need sources and a reason they fit')
+        if c['email']:
+            if emails.setdefault(c['email'].lower(), c['id']) != c['id']:
+                raise ValueError('Email belongs to an existing contact')
+        before = old.get(c['id'], {})
+        if before.get('status') in ('customer', 'opted_out') and c['status'] != before['status']:
+            raise ValueError('Keep customer and opt-out status')
+        merged[c['id']] = {**before, **{k: c[k] for k in FIELDS}, 'manual_notes': before.get('manual_notes', '')}
+    incoming = {m['id']: m for m in messages if m['id'] not in resolved}
+    if len(resolutions) != len(incoming) or {r['id'] for r in resolutions} != set(incoming):
+        raise ValueError('Resolve each new message once')
+    for r in resolutions:
+        if not r['resolution']:
+            raise ValueError('Each message needs a resolution')
+        if r['contact_id']:
+            if r['contact_id'] not in merged:
+                raise ValueError('Message refers to an unknown contact')
+            message, contact = incoming[r['id']], merged[r['contact_id']]
+            if message['contact_id'] != contact['id'] and not (message['email'] and message['email'].lower() == contact['email'].lower()):
+                raise ValueError('Message identity is not established')
+    return merged
+
+
+def check_tasks(day, contacts, tasks):
+    keys = set()
+    for task in tasks:
+        contact = contacts.get(task['contact_id'])
+        if not contact:
+            raise ValueError('Task refers to an unknown contact')
+        if contact['status'] in ('customer', 'opted_out', 'closed'):
+            raise ValueError('Task targets an inactive contact')
+        if datetime.date.fromisoformat(task['due_date']) > datetime.date.fromisoformat(day):
+            raise ValueError('Daily task is not due yet')
+        key = (task['contact_id'], task['action'])
+        if key in keys or not task['action'] or not task['reason']:
+            raise ValueError('Empty or duplicate task')
+        keys.add(key)
+
+
+def research_notes(args):
+    notes = [('Email', args['email_search']['notes']), ('Happenstance', args['prospect_search']['notes'])]
+    notes += [('Pages', e['notes']) for e in args['enrichment']]
+    return '\n\n'.join(f'{name}: {text}' for name, text in notes if text)
+
+
+def save(args):
+    contacts = check_contacts(args['contacts'], args['resolved'], args['messages'], args['enrichment'],
+        args['updated_contacts'], args['resolutions'])
+    check_tasks(args['day'], contacts, args['day_tasks'])
+    notes = research_notes(args)
+    plan_id = digest(json.dumps({k: v for k, v in args.items() if k != 'crm'}, sort_keys=True).encode())
+    current = args['crm']
+    state = json.loads(current)
+    if state.get('last_plan') != plan_id:
+        if digest(current.encode()) != args['crm_sha256']:
+            raise ValueError('CRM changed after it was read; start a new run')
+        saved = {m['id']: m for m in state['messages']}
+        incoming = {m['id']: m for m in args['messages']}
+        for r in args['resolutions']:
+            saved[r['id']] = {**incoming[r['id']], **r}
+        state.update(contacts=list(contacts.values()), messages=list(saved.values()), last_plan=plan_id)
+        state.setdefault('days', {})[args['day']] = {'tasks': args['day_tasks'], 'research_notes': notes}
+        current = json.dumps(state, indent=2) + '\n'
+    lines = ['# Outbound tasks — ' + args['day'], '']
+    for task in args['day_tasks']:
+        contact = contacts[task['contact_id']]
+        lines += [f"## {task['action']}: {contact['name']} · {contact['company']}",
+            'Due: ' + task['due_date'], '', task['reason'], '', task['draft'], '']
+    if not args['day_tasks']:
+        lines += ['No outreach tasks are due today.', '']
+    unresolved = [m for m in state['messages'] if not m['contact_id']]
+    lines += ['## Messages to review', ''] + [m['id'] + ': ' + m['resolution'] for m in unresolved]
+    lines += ['', '## Research notes', '', notes]
+    output = Path(os.environ['METHOD_OUTPUT_DIR'])
+    output.mkdir(parents=True, exist_ok=True)
+    def artifact(name, data):
+        (output / name).write_bytes(data)
+        return {'path': name, 'sha256': digest(data)}
+    return {'tasks': artifact('tasks.md', ('\n'.join(lines) + '\n').encode()),
+        'receipt': artifact('receipt.json', json.dumps({'day': args['day'], 'crm_sha256': digest(current.encode()),
+            'contacts': len(state['contacts']), 'messages': len(state['messages'])}).encode()),
+        'state': {'crm': current}}

package/dist/packages/sdk/examples/outbound-management/crm_test.py

@@ -0,0 +1,141 @@
+import copy
+import importlib.util
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+
+EXAMPLE = Path(__file__).resolve().parent
+FIXTURES = EXAMPLE / 'fixtures'
+spec = importlib.util.spec_from_file_location('outbound_crm', EXAMPLE / 'crm.py')
+crm = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(crm)
+
+
+def fixture(name):
+    return json.loads((FIXTURES / name).read_text())
+
+
+class OutboundTest(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.crm = (FIXTURES / 'crm.json').read_text()
+        self.previous_output = os.environ.get('METHOD_OUTPUT_DIR')
+        os.environ['METHOD_OUTPUT_DIR'] = str(self.root / 'output')
+        self.addCleanup(self.restore_env)
+
+    def restore_env(self):
+        if self.previous_output is None:
+            os.environ.pop('METHOD_OUTPUT_DIR', None)
+        else:
+            os.environ['METHOD_OUTPUT_DIR'] = self.previous_output
+
+    def args(self, day=1):
+        """Return the save_day inputs: read_crm outputs, source outputs, and a plan."""
+        date = f'2026-09-{16+day}'
+        read = crm.read(dict(crm=self.crm, from_date='2026-09-10', day=date))
+        read.pop('target')
+        sources = {**fixture('observations.json'), 'messages': fixture(f'day-{day}/messages.json')}
+        if day == 1:
+            plan = fixture('plan.json')
+        else:
+            contacts = copy.deepcopy(read['contacts'])
+            contacts[0].update(next_action='Propose meeting times', next_action_date=date)
+            new = [m for m in sources['messages'] if m['id'] not in read['resolved']]
+            plan = dict(updated_contacts=[contacts[0]],
+                resolutions=[dict(id=m['id'], contact_id=m['contact_id'],
+                    resolution='Recorded reply' if m['contact_id'] else 'Review sender') for m in new],
+                day_tasks=[dict(contact_id='c1', action='Propose meeting times', due_date=date,
+                    reason='Alex asked to meet', draft='Hello Alex, here are some times.')])
+        return dict(crm=self.crm, day=date, **read, **sources, **plan)
+
+    def test_fixture_outputs_are_current(self):
+        result = crm.save(self.args())
+        self.assertEqual(result['state']['crm'], (FIXTURES / 'state.json').read_text())
+        self.assertEqual((self.root / 'output/tasks.md').read_text(), (FIXTURES / 'tasks.md').read_text())
+        self.assertEqual((self.root / 'output/receipt.json').read_text(), (FIXTURES / 'receipt.json').read_text())
+
+    def test_two_days_and_repeated_save(self):
+        first = self.args()
+        self.crm = crm.save(first)['state']['crm']
+        before = self.crm
+        self.crm = crm.save({**first, 'crm': self.crm})['state']['crm']
+        self.assertEqual(before, self.crm)
+        self.crm = crm.save(self.args(2))['state']['crm']
+        state = json.loads(self.crm)
+        self.assertEqual(len(state['messages']), 4)
+        self.assertEqual(len(state['days']), 2)
+        self.assertEqual(state['contacts'][2]['status'], 'opted_out')
+        self.assertEqual(state['contacts'][1]['status'], 'customer')
+        self.assertEqual(state['contacts'][0]['manual_notes'], 'Keep this owner note.')
+        self.assertIn('Propose meeting times', (self.root / 'output/tasks.md').read_text())
+
+    def test_stale_write_does_not_change_state(self):
+        args = self.args()
+        args['crm'] = self.crm + '\n'
+        with self.assertRaisesRegex(ValueError, 'CRM changed'):
+            crm.save(args)
+        self.assertFalse((self.root / 'output/tasks.md').exists())
+
+    def test_reject_opt_out_task_and_guessed_identity(self):
+        args = self.args()
+        contacts = crm.check_contacts(args['contacts'], args['resolved'], args['messages'],
+            args['enrichment'], args['updated_contacts'], args['resolutions'])
+        task = dict(args['day_tasks'][0], contact_id='c3')
+        with self.assertRaisesRegex(ValueError, 'inactive'):
+            crm.check_tasks(args['day'], contacts, [task])
+        args['resolutions'][2]['contact_id'] = 'c1'
+        with self.assertRaisesRegex(ValueError, 'identity'):
+            crm.save(args)
+
+    def test_keep_owner_notes_opt_outs_and_message_coverage(self):
+        args = self.args()
+        args['updated_contacts'][0]['manual_notes'] = 'Changed by agent'
+        contacts = crm.check_contacts(args['contacts'], args['resolved'], args['messages'],
+            args['enrichment'], args['updated_contacts'], args['resolutions'])
+        self.assertEqual(contacts['c1']['manual_notes'], 'Keep this owner note.')
+        args['updated_contacts'][1]['status'] = 'contacted'
+        with self.assertRaisesRegex(ValueError, 'customer and opt-out'):
+            crm.save(args)
+        args['updated_contacts'][1]['status'] = 'customer'
+        args['resolutions'].pop()
+        with self.assertRaisesRegex(ValueError, 'each new message'):
+            crm.save(args)
+
+    def test_new_prospect_is_saved_with_sources(self):
+        args = self.args()
+        url = 'https://west.example/team'
+        args['prospects'].append(dict(name='Pat Jones', email='', company='West', role='',
+            profile_url='https://www.linkedin.com/in/pat-jones', introduction_path='Through Alex Kim'))
+        args['enrichment'].append(dict(email='pat@west.example', role='Operations lead',
+            fit='Runs a logistics team', sources=[dict(url=url, facts='Operations lead at West')], notes=''))
+        new = dict(id='email:pat@west.example', name='Pat Jones', email='pat@west.example',
+            introduction_path='Through Alex Kim', company='West', role='Operations lead',
+            fit='Runs a logistics team', sources=[url], status='new', next_action='Review introduction',
+            next_action_date='2026-09-17')
+        args['updated_contacts'].append(new)
+        args['day_tasks'].append(dict(contact_id=new['id'], action='Review introduction',
+            due_date='2026-09-17', reason='Matches the target customer', draft='Hello Pat.'))
+        state = json.loads(crm.save(args)['state']['crm'])
+        self.assertEqual(state['contacts'][-1]['sources'], [url])
+        self.assertEqual(state['contacts'][-1]['manual_notes'], '')
+        self.assertIn('Pat Jones', (self.root / 'output/tasks.md').read_text())
+        new['sources'] = ['https://west.example/other']
+        with self.assertRaisesRegex(ValueError, 'not collected'):
+            crm.save(args)
+
+    def test_blocked_or_unsourced_records_fail(self):
+        args = self.args()
+        with self.assertRaisesRegex(ValueError, 'Source access'):
+            crm.check_email(dict(status='blocked', notes='Sign-in required'), args['messages'])
+        with self.assertRaisesRegex(ValueError, 'Duplicate'):
+            crm.check_email(args['email_search'], args['messages'] + args['messages'][:1])
+        with self.assertRaisesRegex(ValueError, 'enrichment sources'):
+            crm.check_enrichment(dict(email='', role='', fit='', sources=[], notes='LinkedIn blocked'))
+
+
+if __name__ == '__main__':
+    unittest.main()

package/dist/packages/sdk/examples/outbound-management/fixtures/README.md

@@ -0,0 +1,15 @@
+# Outbound state test records
+
+These people, companies, messages, and links are fictional. The Python tests use
+these records to check state writes without browser access.
+
+- `crm.json`: the CRM before the first day.
+- `day-1/messages.json`, `day-2/messages.json`: `read_email` output. Day two
+  repeats the first day's messages and adds a request for a meeting.
+- `observations.json`: the other source step outputs for day one
+  (`email_search`, `prospects`, `prospect_search`, `enrichment`).
+- `plan.json`: `update_contacts` and `draft_tasks` output for day one.
+- `state.json`, `tasks.md`, `receipt.json`: what `save_day` makes from them.
+
+The real outbound Method uses an empty starter CRM and gathers from email,
+Happenstance, company websites, and LinkedIn. It does not read these fixtures.

package/dist/packages/sdk/examples/outbound-management/fixtures/crm.json

@@ -0,0 +1,54 @@
+{
+  "target": {
+    "customer": "Operations leaders at small US logistics companies who still process customer requests manually.",
+    "offer": "A service that turns repeated work into reusable automated workflows.",
+    "new_prospects_per_day": 3,
+    "mailbox_url": "https://mail.google.com/mail/u/0/"
+  },
+  "contacts": [
+    {
+      "id": "c1",
+      "name": "Alex Kim",
+      "email": "alex@north.example",
+      "company": "North",
+      "role": "Operations lead",
+      "fit": "Manages a small logistics team",
+      "sources": [],
+      "status": "contacted",
+      "next_action": "Review follow-up",
+      "next_action_date": "2026-09-17",
+      "manual_notes": "Keep this owner note.",
+      "introduction_path": ""
+    },
+    {
+      "id": "c2",
+      "name": "Morgan Bell",
+      "email": "morgan@south.example",
+      "company": "South",
+      "role": "Operations lead",
+      "fit": "Manages a small logistics team",
+      "sources": [],
+      "status": "customer",
+      "next_action": "",
+      "next_action_date": "",
+      "manual_notes": "Keep this owner note.",
+      "introduction_path": ""
+    },
+    {
+      "id": "c3",
+      "name": "Sam Lee",
+      "email": "sam@east.example",
+      "company": "East",
+      "role": "Operations lead",
+      "fit": "Manages a small logistics team",
+      "sources": [],
+      "status": "contacted",
+      "next_action": "",
+      "next_action_date": "",
+      "manual_notes": "Keep this owner note.",
+      "introduction_path": ""
+    }
+  ],
+  "messages": [],
+  "days": {}
+}

package/dist/packages/sdk/examples/outbound-management/fixtures/day-1/messages.json

@@ -0,0 +1,29 @@
+[
+  {
+    "id": "m1",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m1",
+    "email": "alex@north.example",
+    "at": "2026-09-17T09:00:00-04:00",
+    "direction": "received",
+    "text": "Can you send pricing today?",
+    "contact_id": "c1"
+  },
+  {
+    "id": "m2",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m2",
+    "email": "sam@east.example",
+    "at": "2026-09-17T10:00:00-04:00",
+    "direction": "received",
+    "text": "Please stop contacting me.",
+    "contact_id": "c3"
+  },
+  {
+    "id": "m3",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m3",
+    "email": "",
+    "at": "2026-09-17T11:00:00-04:00",
+    "direction": "received",
+    "text": "Alex: send the contract. Sender address was not captured.",
+    "contact_id": ""
+  }
+]

package/dist/packages/sdk/examples/outbound-management/fixtures/day-2/messages.json

@@ -0,0 +1,38 @@
+[
+  {
+    "id": "m1",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m1",
+    "email": "alex@north.example",
+    "at": "2026-09-17T09:00:00-04:00",
+    "direction": "received",
+    "text": "Can you send pricing today?",
+    "contact_id": "c1"
+  },
+  {
+    "id": "m2",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m2",
+    "email": "sam@east.example",
+    "at": "2026-09-17T10:00:00-04:00",
+    "direction": "received",
+    "text": "Please stop contacting me.",
+    "contact_id": "c3"
+  },
+  {
+    "id": "m3",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m3",
+    "email": "",
+    "at": "2026-09-17T11:00:00-04:00",
+    "direction": "received",
+    "text": "Alex: send the contract. Sender address was not captured.",
+    "contact_id": ""
+  },
+  {
+    "id": "m4",
+    "url": "https://mail.google.com/mail/u/0/#inbox/m4",
+    "email": "alex@north.example",
+    "at": "2026-09-18T09:00:00-04:00",
+    "direction": "received",
+    "text": "Thanks for the pricing. Can we meet on September 21? Please send some times.",
+    "contact_id": "c1"
+  }
+]

package/dist/packages/sdk/examples/outbound-management/fixtures/observations.json

@@ -0,0 +1,12 @@
+{
+  "email_search": {
+    "status": "complete",
+    "notes": ""
+  },
+  "prospects": [],
+  "prospect_search": {
+    "status": "complete",
+    "notes": "No new prospects in this state test."
+  },
+  "enrichment": []
+}