The Agentic
Operating Model for Construction.

You are setting up an Obsidian vault to act as the human-facing knowledge layer for a Malaysian Construction & EPC Contractor multi-agent operating system. The 5 specialist agents are Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent; the orchestrator is Chief of Staff. The Group CEO reads from this vault every morning.

Generate the vault structure:
- Folder hierarchy: /agents (one folder per agent code), /decisions, /playbooks, /learned-context, /regulatory, /operations, and the Construction & EPC Contractor-specific entity folders for: projects, sites, subcontractors, materials, plant.
- Frontmatter schemas (YAML) for each note type: decision, playbook, agent-writeback, entity-profile, regulatory-change, outcome.
- Tag taxonomy: priority::P0/P1/P2/Esc, agent::(Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent), status::approved/deferred/escalated, outcome::win/loss/pending, regulator::(CIDB / JKKP / KPKT / DOE).
- Dataview queries the Group CEO uses at 06:00 daily: (a) today's Decision List, (b) this week's escalations, (c) agent-by-agent RM-impact tally, (d) decisions whose outcome::pending is more than 7 days old.

Output a clear directory tree + one fully written sample note per note type (6 notes) with realistic Construction & EPC Contractor-flavoured content.

Design the Pinecone vector index that backs the agents' shared memory for the Construction & EPC Contractor system from the previous prompts. The agents are Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent (plus Chief of Staff orchestrator). Scale: multi-project contractor (~6,000 site & office staff).

Requirements:
- One Pinecone namespace per agent (Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent) plus a shared 'orchestrator' namespace and a 'regulatory' namespace.
- Vector dimensions: 3072 (Voyage 3 large or OpenAI text-embedding-3-large). Justify whether to downscale to 1024 (matryoshka) for cost.
- Per-vector metadata fields: doc_id, agent (one of Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent | Chief of Staff | regulatory), entity_type (one of projects, sites, subcontractors, materials, plant), entity_id, ts (unix), decision_class (forecast | decision | playbook | outcome | regulatory-change), priority, rm_impact (signed float), outcome (win | loss | pending), tags (array).
- Hybrid retrieval: sparse + dense. Include BM25 for exact lookup of entity IDs (Construction & EPC Contractor-specific codes — e.g., branch IDs, project codes, SKU codes, tower IDs).
- Settings: serverless vs pod-based — recommend one for multi-project contractor (~6,000 site & office staff). Justify replica count and metadata-index choice.
- Chunking: 512-token windows, 64-token overlap, but also one vector per H2/H3 section so the agents can cite a specific section back to the Group CEO.

Output as: (a) a Terraform module that provisions the index, (b) a Python pinecone-client setup script that creates the namespaces, (c) a JSON schema validator for the metadata fields, ready to enforce on every upsert.

Build the embedding and ingestion pipeline that turns Obsidian markdown notes into Pinecone vectors for the Construction & EPC Contractor agents (Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent, Chief of Staff).

Pipeline:
1. File watcher on the vault folder (chokidar in Node or watchdog in Python) that fires on save and on git-pull.
2. Parse YAML frontmatter and markdown body via python-frontmatter or gray-matter.
3. Chunk body by H2/H3 boundaries AND by ~512-token windows with 64-token overlap. Preserve heading path as chunk.section_path metadata.
4. Embed via Voyage 3 large (or text-embedding-3-large) — async, batched at 100 items, retry with exponential backoff on 429/5xx.
5. Extract metadata: agent_namespace (from path /agents/<code>/...), entity links (parse [[wikilinks]] from body and map to entity_id), decision_class (from frontmatter), regulatory mentions (regex hit on CIDB / JKKP / KPKT / DOE), rm_impact (from frontmatter), outcome (from frontmatter).
6. Upsert with deterministic IDs: sha256(file_path + chunk_index). Delete-then-upsert on save to avoid stale chunks.
7. Write back to the note's frontmatter: pinecone_ids[], last_embedded_at, chunk_count. Commit back to git for auditability.

Deliverables:
- A Python repo (FastAPI + Pinecone client + Voyage client + python-frontmatter + watchdog) with a docker-compose.yml that starts the watcher and a small admin UI for the Group CEO's chief of staff to trigger re-embed on stale notes.
- An on-failure alerter that posts to Slack/Telegram if any sub-step errors out twice in a row.

Build an MCP (Model Context Protocol) server that exposes the Construction & EPC Contractor Obsidian vault + Pinecone index as queryable tools for the agents (Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent) and Chief of Staff.

Expose these tools:
- search_memory(query, agent_namespace?, entity_type?, entity_id?, date_range?, top_k=10) — hybrid Pinecone retrieval; returns chunks with source-note paths, section_path, and frontmatter metadata.
- get_decision_history(entity_id, days=30) — returns every Daily Decision List entry that touched this projects or other entity.
- get_playbook(name) — returns the most up-to-date playbook for a named scenario. Known playbooks for this industry include: tender win/loss playbook, EOT (extension-of-time) playbook, JKKP-incident playbook.
- get_agent_writeback(agent_code, since) — returns recent forecasts/decisions written by one agent.
- get_outcome(decision_id) — returns the actual outcome of an approved decision; used by the nightly Chief of Staff retraining loop.
- write_note(path, frontmatter, body) — writes a new markdown note to the vault (triggers re-embedding via the Step-3 watcher).
- propose_playbook_update(playbook_name, diff, evidence_decision_ids) — drafts a markdown PR to the playbook with linked evidence.

Implement as a TypeScript MCP server using @modelcontextprotocol/sdk. Configure manifests for: (a) Claude Desktop, (b) Claude Code, (c) n8n's MCP node so the agents can call it as part of the cascade. Output the full source code + a 1-page how-to-install.

Wire up the nightly knowledge-graph sync from production operations to the Obsidian vault and Pinecone for the Construction & EPC Contractor multi-agent system (Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent, Chief of Staff).

Each night at 02:00 MYT:
1. Pull yesterday's outcomes from production: for each Daily Decision List entry, fetch what the Group CEO actually approved / deferred / escalated, the realised RM-impact, and any downstream effect.
2. Stamp outcomes onto each decision note's frontmatter (outcome::win | loss | pending, actual_rm_impact, time_to_outcome).
3. Generate a 'daily writeback' note per agent (Tender Agent, Materials Agent, Crew Agent, Equipment Agent, Project Agent) summarising what it saw, what it recommended, what was approved, and the delta vs forecast. Save under /agents/<code>/writeback/YYYY-MM-DD.md.
4. For every new or updated note, the Step-3 pipeline re-embeds and upserts to Pinecone.
5. Run a "lessons learned" extractor: prompt the Chief of Staff model with the day's outcomes and ask for 3-5 playbook updates. Append as drafts to /playbooks/_drafts/ for Group CEO review.
6. Push a Slack/Telegram digest to the Group CEO's chief of staff: the top 5 lessons, plus any decisions stuck at outcome::pending for >7 days.

Deliverables: (a) an n8n workflow JSON, (b) a Claude Code skill, or (c) a Python cron job — pick the best fit for a multi-project contractor (~6,000 site & office staff) and explain why. Include error handling, retry, and a fail-open mode that alerts a human on any failure.