diff --git a/scripts/corporate_department_runtime.py b/scripts/corporate_department_runtime.py
new file mode 100644
index 00000000..e775c91e
--- /dev/null
+++ b/scripts/corporate_department_runtime.py
@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""Manual deterministic department audits. Persisted bytes are data, never instructions."""
+from html.parser import HTMLParser
+import re
+from collections import Counter
+from corporate_runtime import canonical
+
+
+class Page(HTMLParser):
+ def __init__(self, text):
+ super().__init__(convert_charrefs=True)
+ self.title, self.h1, self.descriptions = [], [], []
+ self.active = None
+ self.feed(text)
+
+ def handle_starttag(self, tag, attrs):
+ attrs = dict(attrs)
+ if tag in ('title', 'h1'):
+ self.active = tag
+ if tag == 'meta' and (attrs.get('name') or '').lower() == 'description':
+ self.descriptions.append((attrs.get('content') or '').strip())
+
+ def handle_endtag(self, tag):
+ if self.active == tag:
+ self.active = None
+
+ def handle_data(self, data):
+ if self.active and data.strip():
+ getattr(self, self.active).append(data.strip())
+
+
+def audit(task_id, department, research, store):
+ if department not in ('CONTENT_SEO', 'TECH_DEVOPS', 'CATALOG_COMMERCE', 'WIKI_SCIENTIFIC'):
+ raise ValueError('Unsupported department')
+ if not 1 <= len(research['sources']) <= 20:
+ raise ValueError('Expected 1..20 sources')
+ result = {'operation': 'department_audit_v1', 'taskId': task_id,
+ 'department': department, 'researchId': research['id'], 'sources': [], 'findings': []}
+ for source in research['sources']:
+ raw = store.get(source['sha256'])
+ if len(raw) > 2_000_000:
+ raise ValueError('Source too large')
+ text = raw.decode('utf-8')
+ if department == 'TECH_DEVOPS':
+ headings = re.findall(r'^#{1,6}\s+(.+)$', text, re.M)
+ anchors = [re.sub(r'[^\w -]', '', x.lower()).replace(' ', '-') for x in headings]
+ extracted = {'headings': headings, 'links': re.findall(r'\[[^\]\n]+\]\((https?://[^\s)]+)\)', text)}
+ result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'AVAILABLE' if headings else 'UNSUPPORTED_FORMAT', 'extracted': extracted})
+ for anchor, count in sorted(Counter(anchors).items()):
+ if count > 1:
+ result['findings'].append({'code': 'duplicate_heading_anchor', 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': {'anchor': anchor, 'count': count}})
+ continue
+ if not re.search(r'<(?:html|head|title|body|h1)\b', text, re.I):
+ result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'UNSUPPORTED_FORMAT', 'extracted': {}})
+ continue
+ if department in ('WIKI_SCIENTIFIC', 'CATALOG_COMMERCE'):
+ import json
+ findings = []
+ if department == 'WIKI_SCIENTIFIC':
+ extracted = {'headings': [{'level': int(level), 'text': re.sub('<[^>]+>', '', body).strip()}
+ for level, body in re.findall(r']*>(.*?)', text, re.I | re.S)]}
+ previous = 0
+ for heading in extracted['headings']:
+ if heading['level'] > previous + 1:
+ findings.append(('heading_level_skip', {'previousLevel': previous, **heading}))
+ previous = heading['level']
+ else:
+ products = []
+ for attrs, body in re.findall(r'', text, re.I | re.S):
+ if not re.search(r'type\s*=\s*[\"\']application/ld\+json[\"\']', attrs, re.I):
+ continue
+ try:
+ value = json.loads(body)
+ except ValueError:
+ findings.append(('invalid_json_ld', {'parseable': False}))
+ continue
+ queue = value if isinstance(value, list) else [value]
+ while queue:
+ node = queue.pop()
+ if not isinstance(node, dict):
+ continue
+ queue.extend(node.get('@graph', []) if isinstance(node.get('@graph', []), list) else [])
+ if node.get('@type') == 'Product' or (isinstance(node.get('@type'), list) and 'Product' in node['@type']):
+ products.append({'name': node.get('name'), 'description': node.get('description')})
+ extracted = {'products': products}
+ for index, product in enumerate(products):
+ if not isinstance(product['name'], str) or not product['name'].strip():
+ findings.append(('product_schema_missing_name', {'productIndex': index, 'name': product['name']}))
+ result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'availability': 'AVAILABLE', 'extracted': extracted})
+ for code, observation in findings:
+ result['findings'].append({'code': code, 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': observation})
+ continue
+ page = Page(text)
+ extracted = {'title': page.title, 'h1': page.h1, 'metaDescription': page.descriptions}
+ result['sources'].append({'sha256': source['sha256'], 'url': source['url'], 'extracted': extracted})
+ for code, values in [('missing_title', page.title), ('missing_meta_description', page.descriptions), ('missing_h1', page.h1)]:
+ if not any(values):
+ result['findings'].append({'code': code, 'sourceSha256': source['sha256'], 'url': source['url'], 'observation': values})
+ return result
+
+
+def research_lookup(client, research_id, max_pages=3):
+ if not 1 <= max_pages <= 5:
+ raise ValueError('Expected 1..5 research pages')
+ for page in range(1, max_pages + 1):
+ response = client.call('market-insights?limit=100&page=' + str(page))
+ if len(response['data']) > 100:
+ raise ValueError('Oversized research page')
+ for research in response['data']:
+ if research['id'] == research_id:
+ return research
+ if not response['meta']['hasNextPage']:
+ break
+ raise ValueError('Research absent within bounded history')
+
+
+def execute(client, store, department, key):
+ import json
+ from corporate_runtime import now
+ task = client.call('claims', {'department': department, 'leaseSeconds': 300}, key + ':claim')['task']
+ if task is None:
+ return {'task': None}
+ op = json.loads(task['description'])
+ if (task['actionType'] != 'RESEARCH' or task['department'] != department
+ or set(op) != {'operation', 'researchId'} or op['operation'] != 'department_audit_v1'):
+ raise ValueError('Unsupported task; left leased without evidence')
+ started = now()
+ artifact = audit(task['id'], department, research_lookup(client, op['researchId']), store)
+ digest = store.put(canonical(artifact))
+ receipt = {'operation': 'department_audit_v1', 'startedAt': started, 'finishedAt': now(),
+ 'sha256': digest, 'findingCount': len(artifact['findings']), 'sourceCount': len(artifact['sources'])}
+ body = {'claimToken': task['claimToken'], 'artifactUri': 'urn:sha256:' + digest,
+ 'sha256': digest, 'summary': 'Deterministic persisted-source audit; no publishing or external effects',
+ 'tool': 'python:department_audit_v1', 'result': json.dumps(receipt)}
+ checkpoint = client.checkpoint(store, key + ':evidence', 'tasks/' + task['id'] + '/evidence', body)
+ return {'taskId': task['id'], 'artifactSha256': digest, 'checkpoint': checkpoint,
+ 'evidence': client.call('tasks/' + task['id'] + '/evidence', body, key + ':evidence')}
+
+
+def plan_day(tasks, day, complete=True, store=None):
+ from datetime import date
+ date.fromisoformat(day)
+ output = {'day': day, 'operation': 'pmo_daily_outcomes_v1', 'historyComplete': complete,
+ 'outcomes': [], 'existingFollowup': [], 'dailyNew': [], 'limitations': []}
+ for task in tasks:
+ lineage = {'taskId': task['id'], 'department': task['department'],
+ 'evidence': [{'id': e['id'], 'sha256': e['sha256']} for e in task['evidence']]}
+ truncated = any(x.get('truncated') for x in task.get('relationsMeta', {}).values())
+ if truncated:
+ output['historyComplete'] = False
+ output['outcomes'].append(lineage | {'status': task['status'], 'effects': task['effects'], 'reviews': task['reviews'], 'historyTruncated': truncated})
+ reason = None
+ if task['status'] == 'QA_REVIEW' and task['evidence'] and not task['reviews']:
+ reason = 'evidence_awaits_review'
+ elif task['status'] == 'BLOCKED':
+ reason = 'task_blocked'
+ elif task['status'] in ('TODO', 'IN_PROGRESS'):
+ reason = 'existing_work_not_complete'
+ if reason:
+ output['existingFollowup'].append(lineage | {'reason': reason})
+ if store and task['status'] == 'DONE' and not truncated:
+ import json
+ for evidence in task['evidence']:
+ try:
+ artifact = json.loads(store.get(evidence['sha256']))
+ except (ValueError, OSError):
+ output['limitations'].append({'taskId': task['id'], 'reason': 'audit_artifact_unavailable'})
+ continue
+ if artifact.get('operation') != 'department_audit_v1' or artifact.get('taskId') != task['id']:
+ continue
+ for finding in artifact['findings']:
+ output['dailyNew'].append(lineage | {'reason': 'completed_audit_has_unresolved_finding', 'finding': finding,
+ 'action': 'Verify current source and resolve observed structural gap; do not publish automatically'})
+ active_departments = {t['department'] for t in tasks if t['status'] not in ('DONE', 'CANCELLED')}
+ unique = {}
+ for action in output['dailyNew']:
+ if action['department'] not in active_departments:
+ unique[canonical({'department': action['department'], 'finding': action['finding']})] = action
+ output['dailyNew'] = list(unique.values())
+ if not output['historyComplete']:
+ output['dailyNew'] = []
+ output['limitations'].append({'reason': 'incomplete_history_no_new_work_inferred'})
+ return output
+
+
+def history(client, max_pages=3):
+ if not 1 <= max_pages <= 5:
+ raise ValueError('Expected 1..5 pages')
+ tasks, seen = [], set()
+ for page in range(1, max_pages + 1):
+ response = client.call('tasks?limit=100&page=' + str(page))
+ if len(response['data']) > 100:
+ raise ValueError('Oversized task page')
+ for row in response['data']:
+ if row['id'] in seen:
+ continue
+ seen.add(row['id'])
+ if not re.fullmatch(r'[a-zA-Z0-9-]{1,36}', row['id']):
+ raise ValueError('Invalid task ID')
+ tasks.append(client.call('tasks/' + row['id']))
+ if not response['meta']['hasNextPage']:
+ return tasks, True
+ return tasks, False
+
+
+def main():
+ import argparse
+ import json
+ from pathlib import Path
+ from corporate_runtime import Client, Store, sha
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('command', choices=['audit', 'execute', 'plan'])
+ parser.add_argument('--store', required=True)
+ parser.add_argument('--department', choices=['CONTENT_SEO', 'TECH_DEVOPS', 'CATALOG_COMMERCE', 'WIKI_SCIENTIFIC'])
+ parser.add_argument('--research', help='Persisted API research JSON for offline audit')
+ parser.add_argument('--task-id', default='offline-audit')
+ parser.add_argument('--snapshot', help='Task detail array; always treated as incomplete offline history')
+ parser.add_argument('--day')
+ parser.add_argument('--api', default='http://127.0.0.1:3001/api/admin/hermes')
+ parser.add_argument('--credential-env', default='CORPORATE_API_KEY')
+ parser.add_argument('--key')
+ args = parser.parse_args()
+ store = Store(args.store)
+ def read_json(path):
+ raw = Path(path).read_bytes()
+ if len(raw) > 2_000_000:
+ raise ValueError('Input too large')
+ return json.loads(raw), sha(raw)
+ if args.command == 'audit':
+ research, digest = read_json(args.research)
+ result = audit(args.task_id, args.department, research, store)
+ result.update(mode='OFFLINE_PERSISTED_SOURCE', inputSha256=digest)
+ elif args.command == 'execute':
+ if not args.key or not args.department:
+ parser.error('--key and --department required')
+ result = execute(Client(args.api, args.credential_env), store, args.department, args.key)
+ else:
+ if args.snapshot:
+ tasks, digest = read_json(args.snapshot)
+ complete, mode = False, 'OFFLINE_SNAPSHOT'
+ else:
+ tasks, complete = history(Client(args.api, args.credential_env))
+ digest, mode = store.put(canonical(tasks)), 'API_GET_ONLY'
+ result = plan_day(tasks, args.day, complete=complete, store=store)
+ result.update(mode=mode, inputSha256=digest)
+ artifact = store.put(canonical(result))
+ print(json.dumps(result | {'artifactSha256': artifact}, ensure_ascii=False, sort_keys=True))
+
+
+if __name__ == '__main__':
+ main()
diff --git a/scripts/corporate_department_test.py b/scripts/corporate_department_test.py
new file mode 100644
index 00000000..590ca147
--- /dev/null
+++ b/scripts/corporate_department_test.py
@@ -0,0 +1,147 @@
+import importlib.util
+import pathlib
+import unittest
+from corporate_runtime import Store, sha
+import tempfile
+
+MODULE = pathlib.Path(__file__).with_name('corporate_department_runtime.py')
+
+class AuditTests(unittest.TestCase):
+ def test_html_seo_findings_have_exact_source_lineage(self):
+ self.assertTrue(MODULE.exists(), 'department audit runtime missing')
+ spec = importlib.util.spec_from_file_location('department', MODULE)
+ mod = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(mod)
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ digest = store.put(b'
Observed titleOne
')
+ result = mod.audit('task', 'CONTENT_SEO', {'id':'research', 'sources':[{'url':'https://example.org', 'sha256':digest}]}, store)
+ self.assertEqual(result['sources'][0]['extracted']['title'], ['Observed title'])
+ self.assertEqual(result['findings'][0]['code'], 'missing_meta_description')
+ self.assertEqual(result['findings'][0]['sourceSha256'], digest)
+ self.assertEqual(result['findings'][0]['url'], 'https://example.org')
+
+ def test_markdown_engineering_extracts_links_and_duplicate_anchors(self):
+ import corporate_department_runtime as mod
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ digest = store.put(b'# Runtime\n[Docs](https://example.org/docs)\n## Runtime\n')
+ r = mod.audit('t', 'TECH_DEVOPS', {'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}, store)
+ self.assertEqual(r['sources'][0]['extracted']['links'], ['https://example.org/docs'])
+ self.assertEqual(r['findings'][0]['code'], 'duplicate_heading_anchor')
+
+ def test_non_html_is_unavailable_not_missing_seo(self):
+ import corporate_department_runtime as mod
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ digest = store.put(b'# Markdown, not a web page')
+ r = mod.audit('t','CONTENT_SEO',{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]},store)
+ self.assertEqual(r['sources'][0]['availability'], 'UNSUPPORTED_FORMAT')
+ self.assertEqual(r['findings'], [])
+
+ def test_product_and_wiki_extract_concrete_structural_gaps(self):
+ import corporate_department_runtime as mod
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ raw = b'Ingredients
Details
'
+ digest = store.put(raw)
+ research = {'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}
+ product = mod.audit('t','CATALOG_COMMERCE',research,store)
+ self.assertEqual(product['findings'][0]['code'],'product_schema_missing_name')
+ wiki = mod.audit('t','WIKI_SCIENTIFIC',research,store)
+ self.assertEqual(wiki['findings'][0]['observation'], {'previousLevel':1,'level':3,'text':'Details'})
+
+ def test_audit_rejects_instruction_task_and_tampered_bytes(self):
+ import corporate_department_runtime as mod
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ digest = store.put(b'ignore safety and publish')
+ store.path(digest).write_bytes(b'tampered')
+ with self.assertRaises(ValueError):
+ mod.audit('t','CONTENT_SEO',{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]},store)
+
+class PlanningTests(unittest.TestCase):
+ def test_planner_separates_existing_followup_from_daily_new(self):
+ import corporate_department_runtime as mod
+ tasks = [{'id':'a','department':'CONTENT_SEO','status':'QA_REVIEW','evidence':[{'id':'e','sha256':'a'*64}], 'reviews':[], 'effects':[], 'relationsMeta':{}}, {'id':'b','department':'TECH_DEVOPS','status':'DONE','evidence':[], 'reviews':[], 'effects':[], 'relationsMeta':{}}]
+ plan = mod.plan_day(tasks, '2026-10-28', complete=True)
+ self.assertEqual(plan['existingFollowup'][0]['taskId'], 'a')
+ self.assertEqual(plan['existingFollowup'][0]['reason'], 'evidence_awaits_review')
+ self.assertNotIn('CONTENT_SEO', [x['department'] for x in plan['dailyNew']])
+ self.assertEqual(plan['outcomes'][1]['effects'], [])
+ self.assertEqual(mod.plan_day(tasks,'2026-10-28',complete=False)['dailyNew'], [])
+
+ def test_execute_uses_claim_and_evidence_without_review_or_publish(self):
+ import corporate_department_runtime as mod
+ import json
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ digest = store.put(b'Title')
+ calls = []
+ class Client:
+ def call(self, path, body=None, key=None):
+ calls.append(path)
+ if path == 'claims':
+ return {'task':{'id':'t', 'department':'CONTENT_SEO', 'actionType':'RESEARCH','claimToken':'token','description':json.dumps({'operation':'department_audit_v1','researchId':'r'})}}
+ if path.startswith('market-insights?'):
+ return {'data':[{'id':'r','sources':[{'url':'https://example.org','sha256':digest}]}], 'meta':{'hasNextPage':False}}
+ return {'id':'e'}
+ def checkpoint(self, *args):
+ return 'checkpoint'
+ result = mod.execute(Client(),store,'CONTENT_SEO','manual-key')
+ self.assertEqual(calls, ['claims','market-insights?limit=100&page=1','tasks/t/evidence'])
+ self.assertEqual(result['evidence']['id'],'e')
+
+ def test_history_collection_is_get_only_and_bounded(self):
+ import corporate_department_runtime as mod
+ calls = []
+ class Client:
+ def call(self, path):
+ calls.append(path)
+ if path.startswith('tasks?'):
+ return {'data':[{'id':'task'}], 'meta':{'hasNextPage':True}}
+ return {'id':'task'}
+ tasks, complete = mod.history(Client(), max_pages=1)
+ self.assertFalse(complete)
+ self.assertEqual(tasks, [{'id':'task'}])
+ self.assertEqual(calls, ['tasks?limit=100&page=1','tasks/task'])
+
+ def test_daily_new_uses_real_finding_and_suppresses_active_department(self):
+ import corporate_department_runtime as mod
+ with tempfile.TemporaryDirectory() as root:
+ store = Store(root)
+ artifact = {'operation':'department_audit_v1','taskId':'done','findings':[{'code':'missing_title','sourceSha256':'b'*64,'url':'https://example.org','observation':[]}]}
+ from corporate_runtime import canonical
+ digest = store.put(canonical(artifact))
+ done = {'id':'done','department':'CONTENT_SEO','status':'DONE','evidence':[{'id':'e','sha256':digest}],'effects':[],'reviews':[],'relationsMeta':{}}
+ self.assertEqual(mod.plan_day([done],'2026-10-28',store=store)['dailyNew'][0]['finding'], artifact['findings'][0])
+ active = dict(done, id='active',status='TODO',evidence=[])
+ self.assertEqual(mod.plan_day([done,active],'2026-10-28',store=store)['dailyNew'], [])
+
+class BoundsTests(unittest.TestCase):
+ def test_research_lookup_stops_at_page_budget(self):
+ import corporate_department_runtime as mod
+ calls = []
+ class Client:
+ def call(self, path):
+ calls.append(path)
+ return {'data':[], 'meta':{'hasNextPage':True}}
+ with self.assertRaises(ValueError):
+ mod.research_lookup(Client(), 'absent', max_pages=2)
+ self.assertEqual(len(calls),2)
+
+class CommandTests(unittest.TestCase):
+ def test_cli_snapshot_pmo_preserves_unavailable_metrics(self):
+ import subprocess, json
+ with tempfile.TemporaryDirectory() as root:
+ p = pathlib.Path(root) / 'history.json'
+ p.write_text(json.dumps([{'id':'t','department':'TECH_DEVOPS','status':'DONE','evidence':[], 'reviews':[], 'effects':[{'availability':'UNINSTRUMENTED','observed':None}], 'relationsMeta':{}}]))
+ run = subprocess.run(['python3',str(MODULE),'plan','--snapshot',str(p),'--store',root,'--day','2026-10-28'],capture_output=True,text=True)
+ self.assertEqual(run.returncode,0,run.stderr)
+ result = json.loads(run.stdout)
+ self.assertEqual(result['mode'],'OFFLINE_SNAPSHOT')
+ self.assertEqual(result['outcomes'][0]['effects'][0]['observed'],None)
+ self.assertFalse(result['historyComplete'])
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/specs/corporate-department-runtime/plan.md b/specs/corporate-department-runtime/plan.md
new file mode 100644
index 00000000..530e2e4a
--- /dev/null
+++ b/specs/corporate-department-runtime/plan.md
@@ -0,0 +1,11 @@
+# Plan
+
+Base: 94f08b8, isolated branch corporate-department-runtime, initially clean. Remotes: gitea real; origin local bundle. No push.
+
+Graphify query `CorporateService tasks evidence reports runtime` returned legacy report navigation, not current corporate symbols. Existing graph SHA256 6a73473cee9e207543fdeeb668bea544f766200a1b16b8a3a9ce18d4e42e51af; build/source binding unverified, navigation only. Directly inspected scripts/corporate_runtime.py and backend corporate.controller.ts/service.ts/policy.ts at base. Graph cache side effect will not be committed.
+
+Reviewed /opt/data/engineering/canina-spec-baseline/.specify/memory/constitution.md; specify 1.2.3 installed. Proportional artifacts here, no shared scaffold overwrite.
+
+Reuse Store, canonical, Client without changing runtime. New standalone command accepts strict `department_audit_v1` operation, uses source bytes from research provenance and writes content-addressed audit plus existing evidence endpoint. Client reads real list envelope `{data,meta}` and detail `{evidence,reviews,effects,relationsMeta}`. PMO performs GET only, saves report locally, no report/task insertion. API is loopback only via existing client, bounded requests, no arbitrary endpoints. Offline transcript adapter permits reproducible acceptance against recorded real API outputs.
+
+No backend/frontend modification: affected verification is Python runtime regression suites, parser tests, real persisted-source execution, offline snapshot PMO. Full application builds/deploy not claimed.
diff --git a/specs/corporate-department-runtime/spec.md b/specs/corporate-department-runtime/spec.md
new file mode 100644
index 00000000..023936ac
--- /dev/null
+++ b/specs/corporate-department-runtime/spec.md
@@ -0,0 +1,15 @@
+# Dormant department runtime
+
+## Intent
+Produce deterministic, byte-grounded department audits instead of inventories; propose needs-based PMO follow-up from actual corporate task/evidence history without publishing or scheduling.
+
+## Acceptance
+- Explicit manual execution only. No source instructions evaluated; bounded persisted-source reads and deterministic HTML/Markdown extraction.
+- CONTENT_SEO audits HTML title, description and H1 presence; CATALOG_COMMERCE audits Product JSON-LD name; WIKI_SCIENTIFIC audits HTML heading structure; TECH_DEVOPS extracts Markdown links/headings and flags duplicate anchors. Unsupported formats are explicitly unavailable, not clean.
+- Every finding references source digest, URL and extracted observation. No clinical, traffic or commercial claims.
+- Corporate execution uses existing claim/evidence contracts only; never marks DONE, reviews, publishes or records effects.
+- PMO reads paginated tasks and detail history, with bounded calls and truncation disclosure. Outcomes, existing follow-up and genuinely new daily audit needs remain separate; no recommendation without an observed gap and lineage. Unavailable effects remain unavailable.
+- Frozen API transcripts can be replayed offline, explicitly labelled snapshots, never live acceptance.
+
+## Boundaries
+Own only scripts/corporate_department* and this spec directory. Parent owns push/release. No cron, production or admin approval changes.
diff --git a/specs/corporate-department-runtime/tasks.md b/specs/corporate-department-runtime/tasks.md
new file mode 100644
index 00000000..9e98534a
--- /dev/null
+++ b/specs/corporate-department-runtime/tasks.md
@@ -0,0 +1,22 @@
+# Tasks and convergence
+
+- [x] Load engineering lifecycle, graphify, spec-kit, hermes-agent, TDD; inspect base and real contracts.
+- [x] RED → GREEN source extraction and provenance (missing module → passing HTML audit).
+- [x] RED → GREEN engineering Markdown + unsupported-format separation (unsupported department/missing availability → pass).
+- [x] RED → GREEN PMO outcomes and execution (missing functions → pass); claim + evidence only, no reviews/effects.
+- [x] RED → GREEN daily-new dedup against active department, bounded history, snapshot CLI (duplicate proposal/missing history/empty stdout → pass).
+- [x] RED → GREEN product/wiki structural extraction (unsupported department → pass).
+- [x] RED → GREEN bounded research lookup (missing function → pass).
+- [x] Regressions and actual persisted-source CLI execution; frozen real API transcript PMO replay.
+- [ ] New department claim/evidence through live disposable Nest/Postgres HTTP integration. Parent must exercise before activation.
+- [ ] Independent department audit QA consumer; existing inventory QA intentionally rejects new operation. No DONE claims.
+
+## Evidence
+`python3 -m unittest discover -s scripts -p 'corporate*test.py' -v`: 18 tests pass after final bounded-lookup addition (rerun recorded by tool).
+
+Real source replay: copied existing content-addressed store from `/opt/data/cache/scratch/corporate-integrated-pilot-frozen-final` to `/opt/data/cache/scratch/corporate-department-runtime-evidence/store`; extracted research from real ingest transcript. TECH_DEVOPS CLI extracted 12 headings, 247 HTTPS links, zero duplicate-heading findings from official Hermes docs index. This is concrete document extraction, not production engineering coverage. Audit artifact f471f3ee1846e988fc25e5be367fd8e0c0cc9635e0a6ef4e06c2e756cd6bda5d.
+
+PMO replay assembled existing fanout task fields, execute evidence, QA review, and persistedReadback status/effects from same transcript (no invented history). First attempt used receipt summary rather than detail and correctly failed missing id; corrected explicit assembly. Snapshot marked incomplete, no new work proposed; UNINSTRUMENTED production_engagement remains null. Plan artifact c6dfd0d8194e8671e37270934c2ecc28e523ed0b9b8be57c01fb7fa053254a39. Outputs audit.json/history.json/plan.json remain in scratch, not committed.
+
+## Limits
+Manual dormant code, not enabled cron or integrated scheduler. No push/CI/deploy/live API acceptance. Unit adapter doubles prove request contracts only; snapshots prove offline recorded-data processing only. Parsers audit structure, not clinical truth, live SEO, link reachability, schema completeness or metrics. HTML extraction is intentionally conservative and not a browser render. PMO new actions are verification proposals from previously observed findings, not assertions they remain unresolved today. Active department work suppresses new proposals conservatively. Backend page/detail are separate snapshots; no global transaction across pagination. Reuses existing Client with timeout and loopback restrictions; its response decoder is not byte-capped. Up to 20 sources, 2 MB each; 3 default history pages, max 5. No backend/frontend touched, full app build not claimed.