@haus-tech/haus-workflow 4.1.0 → 4.2.0

package/library/global/skills/slack-cowork/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: slack-cowork
+description: Speglar en Slack-kanals canvases till en lokal projektmapp, håller dem synkade och skapar nya. Använd den här skillen när användaren vill koppla upp sessionen mot en Slack-kanal, hämta ner eller "suga ner" canvases, arbeta med utkast lokalt innan de publiceras, pusha ändringar tillbaka till Slack, eller skapa en ny canvas i en kanal. Använd den också i början av en session som gäller ett projekt med en kopplad Slack-kanal — då behöver du synka och läsa av vad som ändrats sedan sist innan något annat arbete påbörjas. Utlöses av fraser som "koppla upp mot #kanal", "synka kanalen", "läs in canvasarna", "pusha till Slack", "publicera utkastet", "vad har hänt i kanalen", "slack-cowork".
+---
+
+# slack-cowork
+
+Gör en Slack-kanal till en lokal arbetsyta. Utkast lever som markdown på disk där iteration är snabb och osynlig för andra. Slack är publiceringsytan — dit går bara det som medvetet skickas upp.
+
+## Krav
+
+Skillen behöver tre saker: Slack-kopplingen påslagen i chatten, ett skrivbart filsystem, och underagenter för nedladdningen.
+
+| Miljö                       | Stöd                                                                                         |
+| --------------------------- | -------------------------------------------------------------------------------------------- |
+| Cowork, moln med delad mapp | Fullt                                                                                        |
+| Cowork, på egen dator       | Fullt                                                                                        |
+| Claude Code                 | Fullt                                                                                        |
+| claude.ai-chatt             | Delvis — canvases går att läsa och uppdatera, men ingen lokal spegling och inga underagenter |
+
+Saknas filsystem eller underagenter: säg det innan du börjar, och erbjud den delmängd som fungerar — läsa en canvas och uppdatera den direkt. Bygg inte mappstrukturen halvvägs.
+
+## Varför skillen ser ut som den gör
+
+Tre förhållanden formar hela designen. Förstår du dem blir resten självklart.
+
+**Sessioner har inget minne.** Arbetet lever bara vidare om det ligger i kanalen eller på disken. Därför börjar varje session med en synk, och därför är det värt att vara noggrann med att skriva ner beslut.
+
+**Innehåll passerar alltid genom sammanhanget.** Det finns ingen ledning från Slack till filsystemet som går förbi dig. En canvas på 43 KB kostar ungefär 11 000 tokens att hämta. Därför sker nedladdning i underagenter som skriver till disk och bara rapporterar tillbaka en rad.
+
+**Slack berättar inte vem som ändrat vad inne i en canvas.** Ingen upphovsinformation per sektion finns att hämta. Därför bygger konfliktdetekteringen på lokala ögonblicksbilder i `.snapshot/`. Den mappen är hela säkerhetsmekanismen.
+
+## Mappar och register
+
+Speglingen ligger i projektets egen mapp, eftersom kanalens dokument hör ihop med projektets övriga material och ska följa med när mappen delas.
+
+**Varje canvas har exakt en lokal arbetsfil.** Det är den viktigaste regeln i hela skillen. Finns två filer med samma innehåll vet varken du eller användaren vilken som ska redigeras, och nästa session gissar fel. Manifestets `lokal_fil` pekar ut den enda arbetsfilen; sökvägen är relativ projektmappens rot och får peka var som helst i projektet.
+
+```
+<projektmapp>/
+├── forvaltningsmodellen.md          # arbetsfil, låg redan här — redigera denna
+├── genomforande-arbetsdokument.md   # arbetsfil
+└── slack/<kanalnamn>/
+    ├── manifest.json
+    ├── canvas/<slug>.md             # ENDAST dokument som föddes i Slack
+    ├── .snapshot/<slug>.md          # som Slack såg ut vid senaste synk — rör aldrig
+    ├── historik.md                  # löpande logg, nyaste överst
+    └── historik-arkiv.md
+```
+
+`canvas/`-mappen är till för dokument hämtade från Slack som saknar lokal förlaga. Ett dokument som redan fanns lokalt och konverterats till canvas stannar där det låg — att kopiera in det under `canvas/` skapar just den tvetydighet regeln finns för att undvika.
+
+Ett register i `.slack-cowork.json` mappar kanal till projektmapp och pekar ut vilken kanal som är aktiv. Det finns för att samma kanal aldrig ska speglas från två håll — två `.snapshot/` som båda tror sig vara sanningen ger tyst felaktig konfliktdetektering.
+
+Registret läggs i roten av den delade mappen, inte i användarens hemkatalog. I Cowork når du användarens filer genom en enhetsbrygga vars hemkatalog är knuten till sessionen och försvinner med den; bara delade mappar överlever. Delas en rotmapp med flera projekt under sig, lägg registret där — då täcker det alla projekt i roten. Delas ett enskilt projekt, lägg det i projektmappen.
+
+Leta efter registret i roten av varje delad mapp innan du antar att ingen kanal är ansluten.
+
+Scheman för register och manifest finns i `references/synk.md`. Läs den filen innan du skriver något av dem.
+
+## Flöden
+
+### Anslut en kanal
+
+När användaren ber dig koppla upp mot en kanal:
+
+1. Slå upp kanalen med `slack_search_channels`. Sätt `channel_types="public_channel,private_channel"` — verktyget söker annars bara publika kanaler, och de flesta arbetskanaler är privata.
+2. Kontrollera registret. Är kanalen redan speglad någon annanstans — säg det och fråga innan du gör något mer. Skapa aldrig en andra spegling.
+3. Inventera kanalens dokument med `slack_search_public_and_private`: `content_types="files"`, frågan `type:canvases in:<#KANAL_ID>`, `include_context=false` och `response_format="concise"`. De två sista håller nere det som dras in i sammanhanget — du behöver bara metadata här.
+4. Skapa mappstrukturen och manifestet, ladda ner allt enligt mönstret nedan.
+5. Rapportera vad som hämtades: antal, titlar, ägare, storlek.
+
+**Paginera alltid.** Sökningen returnerar högst 20 träffar per anrop. Följ `next_cursor` tills den tar slut. En ofullständig inventering är värre än ingen alls: dokument som inte kom med flaggas vid nästa synk som borttagna ur Slack, trots att de finns kvar.
+
+Inventera även `type:lists in:<#KANAL_ID>` och för in eventuella listor i manifestet med status `endast_index`. Kopplingen har inga verktyg för att läsa eller skriva Slack-listor — bara canvases. Säg det rakt ut när du redovisar dem, så att ingen tror att de går att arbeta med.
+
+### Synka vid sessionsstart
+
+Gör detta _innan_ något annat arbete påbörjas. Poängen är inte att hämta filer utan att användaren ska få veta vad som hänt sedan sist innan hen fattar beslut.
+
+1. Inventera kanalen på nytt och jämför mot manifestet.
+2. Hämta det som är nytt eller vars ändringsdatum är nyare än manifestets. Hoppa över det oförändrade — efter första synken är de flesta sessioner nästan gratis.
+3. Finns ett dokument lokalt men inte längre i Slack: flagga det. Radera aldrig lokalt material på eget bevåg. Kontrollera först att inventeringen paginerats färdigt och att dokumentet inte skapats så nyligen att sökindexet inte hunnit med.
+
+   Leta samtidigt efter dubbletter: en fil någon annanstans i projektet med nästan identiskt innehåll som en registrerad arbetsfil. Välj inte åt användaren vilken som gäller — visa båda sökvägarna och fråga. Dubbletter uppstår lätt vid konvertering och är tysta tills någon redigerar fel fil.
+
+4. Läs kanalhistoriken sedan senaste synk med `slack_read_channel` och lägg en kort sammanfattning överst i `historik.md`. Beslut fattas ofta i chatten och hinner aldrig in i dokumenten — det är därför historiken är värd att spara.
+
+   Sätt `oldest` till tidpunkten för senaste synk. Parametern tar en **Unix-timestamp**, medan manifestet lagrar ISO 8601 — konvertera. Utan `oldest` får du bara de senaste 100 meddelandena och längre luckor försvinner tyst. Är luckan större än 100 meddelanden, paginera med `cursor`.
+
+5. Rapportera driften: vad som ändrats, av vem, när, och vilka lokala filer som nu avviker.
+
+Växer `historik.md` förbi ungefär 50 KB, flytta de äldsta posterna till `historik-arkiv.md`.
+
+### Nedladdningsmönstret
+
+Starta en underagent per dokument som ska hämtas, parallellt i samma tur. Ge varje agent i uppdrag att:
+
+- anropa `slack_read_canvas` med dokumentets ID
+- skriva innehållet till `canvas/<slug>.md` och en identisk kopia till `.snapshot/<slug>.md`
+- returnera **endast** en rad JSON med nycklarna `id`, `titel`, `sokvag`, `storlek_kb`, `antal_sektioner`
+
+Agentens svar är returvärdet, inte ett meddelande till en människa. Innehållet ska aldrig komma tillbaka i svaret — hela poängen är att det brinner i agentens sammanhang och inte i ditt.
+
+Behövs inga nedladdningar, starta inga agenter.
+
+När ett dokument faktiskt ska bearbetas läser du den lokala filen på vanligt sätt. Ha inte fler än två–tre stora dokument aktiva samtidigt.
+
+### Arbeta lokalt
+
+Ingen Slack-kontakt alls. Redigera markdown-filerna under `canvas/` fritt. Det är här iterationen ska ske — billigt, snabbt och utan att halvfärdiga resonemang syns för teamet.
+
+### Pusha till Slack
+
+Push sker på uttrycklig order — "pusha", "publicera", "lägg upp". Aldrig automatiskt, eftersom canvasen är något användaren medvetet visar för sitt team.
+
+1. Läs canvasen färskt med `slack_read_canvas`. Du behöver både dess nuvarande innehåll och färska sektions-ID:n.
+2. Jämför i tre led per sektion: lokal fil, `.snapshot/`, och Slack. `references/synk.md` beskriver utfallen.
+3. Lint:a innehållet mot canvas-markdown enligt `references/canvas-markdown.md`. Ett utkast som bryter mot reglerna går sönder vid push, ofta tyst.
+4. Skicka alla ändringar i ett enda `slack_update_canvas` med flera operationer i `sections`. De tillämpas atomiskt mot samma ögonblicksbild. Taket är 100 operationer — behövs fler, dela upp och läs om sektions-ID:n mellan varje omgång, eftersom de ändras vid varje skrivning.
+5. Skriv om `.snapshot/` och uppdatera manifestet.
+
+**Sektions-ID:n är färskvara.** De ändras vid varje skrivning. Steg 1 måste ske omedelbart före steg 4 — aldrig från minnet, aldrig från en tidigare tur. Använder du ett gammalt ID skriver du över fel sektion.
+
+### Konflikter
+
+Har samma sektion ändrats både lokalt och i Slack: **stoppa hela pushen och fråga.**
+
+Visa båda versionerna sida vid sida och låt användaren avgöra — lokal, fjärr, eller sammanslagning. Pusha inte de okonfliktade sektionerna under tiden; ett halvpushat dokument är svårare att reda ut än ett opushat.
+
+Detta är skillens viktigaste skyddsräcke. Du kan inte se vem som skrivit vad, så en gissning här är en gissning om någon annans arbete.
+
+### Skapa en ny canvas
+
+1. `slack_create_canvas` med titel och innehåll.
+2. Posta länken i kanalen med `slack_send_message` så teamet ser den.
+3. Lägg till i manifestet och skriv lokal fil plus snapshot.
+
+`slack_create_canvas` tar ingen kanalparameter — canvasen skapas fristående. Det är först när länken postas i kanalen som den blir en kanalfil och dyker upp i inventeringen.
+
+**Sökindexet släpar några minuter.** En nyss skapad canvas syns inte direkt i `type:canvases in:<#KANAL_ID>` även om allt gått rätt till. Flagga den därför aldrig som saknad vid samma eller nästkommande synk — vänta tills den hunnit indexeras. Skriv in den i manifestet direkt; inventeringen kommer ikapp.
+
+Vill användaren dessutom ha canvasen som flik i kanalen får hen fästa den manuellt. Det går inte via kopplingen.
+
+### Konvertera en lokal fil till canvas
+
+När en befintlig markdown-fil ska bli en canvas:
+
+1. Lint:a innehållet enligt `references/canvas-markdown.md`. Rätta struktur, aldrig sak.
+2. Använd filens första rubrik som `title` och utelämna den ur `content` — Slack sätter titeln själv.
+3. Skapa canvasen och posta länken i kanalen.
+4. **Skriv tillbaka den lintade texten till källfilen** och lägg en identisk kopia i `.snapshot/`. Källfilen blir arbetsfilen.
+5. Registrera den i manifestet med `lokal_fil` pekande på källfilen och `ursprung: "lokal"`.
+
+Steg 4 är lätt att göra fel. Lintningen ändrar texten — listmarkörer, tomrader — och görs den bara på vägen upp avviker källfilen direkt från Slack. Nästa push visar då skillnader som ingen människa orsakat.
+
+Kopiera aldrig källfilen till `canvas/`. Två filer med samma innehåll är precis det problem den här skillen finns för att undvika.
+
+### Föreslå synk
+
+Du får föreslå en push när ett arbetssteg framstår som avslutat eller ett beslut fattats. Håll förslaget kort och peka på vad som skulle publiceras:
+
+> Avsnitt 4 har fått två låsta beslut sedan senaste synken. Pusha upp?
+
+Utför aldrig pushen på eget bevåg. Förslaget är en påminnelse, inte en begäran om tyst samtycke.
+
+## Avgränsa alltid sökningen till kanalen
+
+`slack_search_public_and_private` når allt användaren har åtkomst till — privata kanaler, alla DM, personliga anteckningskanaler. Filtrera därför **alltid** med `in:<#KANAL_ID>`.
+
+Utan filtret drar du in kundkonversationer, lösenord och annat som varken hör till uppgiften eller bör hamna i sammanhanget. Det är inte en teknisk begränsning utan en fråga om att inte läsa mer än uppgiften kräver.
+
+## Flera kanaler
+
+En aktiv kanal åt gången. Push- och konfliktlogiken är tillståndsberoende, och parallella kanaler mångdubblar sätten att skriva till fel ställe.
+
+Att _läsa_ från andra kanaler som referens går bra. Skriv aldrig utanför den aktiva kanalen utan att användaren uttryckligen bytt.
+
+## Git för snapshots
+
+Valfritt per kanal via `git_snapshot` i registret, avstängt som standard. Är projektmappen ett git-repo och flaggan påslagen: commita `.snapshot/` efter varje synk med ett genererat meddelande.
+
+Fallerar git med lås- eller behörighetsfel beror det oftast på att mappen nås via enhetsbryggan från en molnsession. Det är miljön, inte skillen. Säg det, och föreslå antingen att flaggan stängs av eller att sessionen körs på användarens egen dator.
+
+## Referensfiler
+
+- `references/synk.md` — register- och manifestscheman, trevägsjämförelsen i detalj, konfliktdialogen. Läs innan du skriver manifest eller genomför en push.
+- `references/canvas-markdown.md` — den tillåtna delmängden av markdown och hur vanliga fel rättas. Läs före varje push och innan du skapar en ny canvas.

package/library/global/skills/slack-cowork/references/canvas-markdown.md

@@ -0,0 +1,160 @@
+# Canvas-markdown
+
+Canvas-markdown är en delmängd av vanlig markdown. Ett lokalt utkast som bryter mot reglerna nedan går sönder vid push — ibland med felmeddelande, ibland tyst genom att formatering försvinner.
+
+Gå igenom listan före varje push och innan du skapar en ny canvas. Rätta automatiskt där det är entydigt; fråga där en rättning skulle ändra innebörden.
+
+## Innehåll
+
+Rubriker · Listor · Tabeller · Referenser och länkar · Datum · Block och avgränsare · Layouter och callouts · Innehållsförteckningar · Vanliga fel och rättningar
+
+_Innehållsförteckningen ovan är avsiktligt utan länkar — se avsnittet om innehållsförteckningar nedan._
+
+## Rubriker
+
+Endast `#`, `##` och `###`. Djupare nivåer underkänns.
+
+Har utkastet `####` finns två rimliga rättningar: höj hela hierarkin ett steg om dokumentet har utrymme, eller gör om nivån till fetstilt brödtext. Välj det senare när dokumentet redan använder alla tre nivåerna meningsfullt.
+
+Rubriker får inte ligga inuti listpunkter.
+
+## Listor
+
+Listpunkter får bara innehålla stycken med inline-formatering — fet, kursiv, `kod`, länkar.
+
+Inte tillåtet i listpunkter:
+
+- kodblock
+- rubriker
+- blockcitat
+
+Nästlade listor får inte blanda typ. En numrerad lista kan bara innehålla numrerade underlistor; en punktlista bara punktade. Blandar utkastet, gör om underlistan till samma typ som föräldern.
+
+Kodblock, blockcitat och rubriker måste skiljas från listor med tomrad.
+
+Kryssrutor fungerar: `- [ ]` och `- [x]`.
+
+## Tabeller
+
+Vanlig markdown-tabellsyntax fungerar.
+
+Radbrytning i en cell skrivs som `<br>` — aldrig som faktisk radbrytning, den bryter tabellen.
+
+Escape-sekvenser i celler (`\>`, `\*`, `\-`, `\#`) ska bevaras exakt.
+
+Blockcitat får förekomma i celler men bara med ren text och inline-formatering.
+
+Tabeller får inte ligga i layouter eller callouts.
+
+## Referenser och länkar
+
+| Vad       | Skrivs som                            |
+| --------- | ------------------------------------- |
+| Användare | `![](@U15CTCJ83)`                     |
+| Kanal     | `![](#C15CTCJ83)`                     |
+| Länk      | `[text](https://exempel.se)`          |
+| Bild      | `![alt](https://exempel.se/bild.png)` |
+
+Vinkelparenteser är fel i alla dessa fall. `<@U123>` och `<#C123>` renderas inte — de blir synlig råtext. Detta gäller även inuti citerad text.
+
+Använd alltid kanalens ID, aldrig dess namn.
+
+En användarreferens på egen rad renderas som ett större profilkort; inline blir den formaterad text. Välj efter avsikt.
+
+Tillåtna URL-scheman: `http`, `https`, `mailto`, `tel`, `ftp`, `slack`, samt relativa sökvägar som börjar med `/`. Andra scheman tas bort tyst.
+
+Länkar ska inte omges av vinkelparenteser.
+
+## Datum
+
+Datum skrivs `![](slack_date:ÅÅÅÅ-MM-DD)` och ingenting annat på samma rad. Ingen veckodag, ingen efterföljande datumtext.
+
+Rätt:
+
+```
+## ![](slack_date:2026-08-14)
+```
+
+Fel:
+
+```
+## ![](slack_date:2026-08-14) 14 augusti – fredag
+```
+
+Detta gäller även deadlines och milstolpar i löpande text.
+
+## Block och avgränsare
+
+Avgränsare (`---`, `***`, `___`) endast på toppnivå.
+
+Blockcitat får innehålla stycken, rubriker, listor och kodblock — men inte avgränsare, bilder, kort, callouts, kolumner, tabeller eller andra blockcitat.
+
+Slack-emoji fungerar: `:tada:`, `:large_green_circle:`.
+
+## Layouter och callouts
+
+Callout:
+
+```
+::: {.callout}
+Innehållet
+:::
+```
+
+Layout med kolumner, högst tre:
+
+```
+::: {.layout}
+::: {.column}
+Första kolumnen
+:::
+::: {.column}
+Andra kolumnen
+:::
+:::
+```
+
+Tabeller och callouts fungerar inte inuti layouter. Callouts kan inte nästlas i andra element.
+
+Använd callouts sparsamt — till varningar och förutsättningar, inte som allmän betoning.
+
+## Innehållsförteckningar
+
+Rena ankarlänkar (`[Rubrik](#rubrik)`) stöds inte. De tas bort tyst vid push — texten blir kvar men blir oklickbar.
+
+En fungerande intern länk använder canvasens egen URL med sektions-ID:
+
+```
+[Principerna](https://<workspace>.slack.com/docs/<team_id>/<file_id>?focus_section_id=<section_id>)
+```
+
+Sektions-ID:n hämtas ur `section_id_mapping` från `slack_read_canvas`. De ändras vid varje skrivning, så en innehållsförteckning byggd så här måste byggas om vid varje push där sektioner tillkommer eller försvinner.
+
+Det gör innehållsförteckningar dyra att underhålla. Har ett lokalt utkast en förteckning med ankarlänkar: fråga om den ska byggas om med riktiga sektionslänkar eller skrivas om utan länkar. Skriv inte tyst bort den.
+
+## Slack-filer
+
+Filer med URL under `*.slack.com/files/*` bäddas in som `![](filreferens)`. På egen rad blir det ett kort, inline blir det klickbar text.
+
+Använd inte den syntaxen för filer som ligger någon annanstans — där gäller vanlig länkformatering.
+
+## Vanliga fel och rättningar
+
+| Fel i utkastet                        | Rättning                                                    |
+| ------------------------------------- | ----------------------------------------------------------- |
+| `#### Underrubrik`                    | `**Underrubrik**` som brödtext, eller höj hela hierarkin    |
+| `<@U01K3CTC6C8>`                      | `![](@U01K3CTC6C8)`                                         |
+| `<#C0BR16H72RE>`                      | `![](#C0BR16H72RE)`                                         |
+| `<https://exempel.se>`                | `[exempel.se](https://exempel.se)`                          |
+| Kodblock inuti listpunkt              | Lyft ut kodblocket ur listan, med tomrad före och efter     |
+| Punktlista nästlad i numrerad         | Gör om underlistan till numrerad                            |
+| Faktisk radbrytning i tabellcell      | `<br>`                                                      |
+| `2026-08-14 (fredag)` som datumrubrik | `![](slack_date:2026-08-14)`                                |
+| Tabell inuti callout                  | Flytta ut tabellen ur callouten                             |
+| `[Avsnitt 3](#avsnitt-3)`             | Sektionslänk med `?focus_section_id=`, eller ta bort länken |
+
+## Titelsektionen
+
+Vid `slack_update_canvas` mot dokumentets första sektion — titeln — skickas endast en rad, högst 255 byte, utan radbrytningar. Brödtext som ska följa efter titeln skickas som en separat operation mot en egen sektion.
+
+Vid `slack_create_canvas` sätts titeln i fältet `title` och ska inte upprepas i `content`.

package/library/global/skills/slack-cowork/references/synk.md

@@ -0,0 +1,226 @@
+# Synk, register och konflikter
+
+Detaljerna bakom flödena i SKILL.md. Läs den här filen innan du skriver ett manifest eller genomför en push.
+
+## Innehåll
+
+- [Registret](#registret)
+- [Manifestet](#manifestet)
+- [Slugar](#slugar)
+- [Trevägsjämförelsen](#trevägsjämförelsen)
+- [Konfliktdialogen](#konfliktdialogen)
+- [Sektionshantering vid push](#sektionshantering-vid-push)
+- [Nedladdning via underagenter](#nedladdning-via-underagenter)
+- [Historikformat](#historikformat)
+- [Återställning när snapshot saknas](#återställning-när-snapshot-saknas)
+
+## Registret
+
+`.slack-cowork.json` i roten av en delad mapp är det enda skillen letar upp på egen hand. Allt annat hittas därifrån.
+
+**Lägg det aldrig i hemkatalogen.** I Cowork nås användarens filer genom en enhetsbrygga där hemkatalogen är sessionsbunden — en sökväg som `/sessions/rcw-.../` finns inte kvar nästa gång. Bara delade mappar överlever. Registret hör därför hemma i roten av den delade mappen: är en rotmapp delad med flera projekt under sig ligger det där och täcker alla; är ett enskilt projekt delat ligger det i projektmappen.
+
+Sök efter filen i roten av varje delad mapp innan du drar slutsatsen att ingen kanal är ansluten.
+
+```json
+{
+  "kanaler": {
+    "C0BR16H72RE": {
+      "namn": "tech-business-development",
+      "projektmapp": "/Users/jonas/Dev/ClaudeCowork/New Tech Business Model",
+      "git_snapshot": false,
+      "ansluten": "2026-08-14T09:12:00+02:00"
+    }
+  },
+  "aktiv_kanal": "C0BR16H72RE"
+}
+```
+
+`aktiv_kanal` avgör vart skrivningar går. Läsning från andra kanaler är fri; push, canvasskapande och manifestuppdateringar sker bara mot den aktiva. Byte kräver uttrycklig order från användaren — sätt då om fältet och säg vilken kanal som nu gäller.
+
+Pekar flera kanaler mot samma `projektmapp` får de egna undermappar under `slack/`. Det är tillåtet, men bara en åt gången kan vara aktiv.
+
+Registret finns för att en kanal aldrig ska speglas från två projektmappar samtidigt. Två `.snapshot/` betyder två olika uppfattningar om vad Slack innehöll senast, och då blir konfliktdetekteringen fel utan att någon märker det.
+
+Försöker någon ansluta en redan registrerad kanal från en annan mapp: avbryt, visa var den redan är speglad, och fråga. Flytt är ett medvetet beslut, inte något som ska ske i förbifarten.
+
+## Manifestet
+
+`<projektmapp>/slack/<kanalnamn>/manifest.json`
+
+```json
+{
+  "kanal": { "namn": "tech-business-development", "id": "C0BR16H72RE" },
+  "senaste_synk": "2026-08-14T09:12:00+02:00",
+  "dokument": [
+    {
+      "id": "F0BPV7VLGSH",
+      "titel": "Haus förvaltningsmodell",
+      "typ": "canvas",
+      "agare": "jonas.landgard",
+      "andrad": "2026-08-14T08:01:49+02:00",
+      "lokal_fil": "forvaltningsmodellen.md",
+      "snapshot": ".snapshot/haus-forvaltningsmodell.md",
+      "status": "synkad",
+      "ursprung": "lokal"
+    }
+  ]
+}
+```
+
+`lokal_fil` är relativ projektmappens rot och får peka var som helst i projektet. Det är manifestet, inte mappstrukturen, som avgör vilken fil som hör till vilken canvas.
+
+`ursprung` är `lokal` för dokument som fanns som fil innan de blev canvas — de ligger kvar där de låg — och `slack` för dokument hämtade från kanalen, som placeras under `canvas/<slug>.md`.
+
+`snapshot` är relativ kanalmappen och använder alltid slugen, oavsett vad arbetsfilen heter.
+
+**Skapa aldrig en andra kopia av en arbetsfil.** Två filer med samma innehåll gör det omöjligt att veta vilken som ska redigeras, och felet märks först när någon arbetat en stund i fel fil. Hittar du en dubblett vid synk: visa båda sökvägarna och fråga vilken som gäller — välj inte åt användaren.
+
+`status` är ett av:
+
+| Värde              | Betyder                                                     |
+| ------------------ | ----------------------------------------------------------- |
+| `synkad`           | Lokal fil, snapshot och Slack är identiska                  |
+| `lokala_ändringar` | Lokal fil avviker från snapshot; Slack oförändrad           |
+| `fjärrändringar`   | Slack avviker från snapshot; lokal fil oförändrad           |
+| `konflikt`         | Båda avviker från snapshot                                  |
+| `endast_index`     | Dokumentet är känt men kan inte läsas — gäller Slack-listor |
+| `saknas_i_slack`   | Finns lokalt men hittades inte vid senaste inventering      |
+
+Sätt aldrig `saknas_i_slack` utan att först ha paginerat inventeringen färdigt. Den näst vanligaste orsaken till felaktig flaggning är en nyss skapad canvas: Slacks sökindex släpar några minuter, så ett dokument som skapades under samma session kan saknas i inventeringen trots att det finns. Vänta till en senare synk innan du drar slutsatser om det.
+
+## Slugar
+
+Filnamn härleds från titeln: gemener, mellanslag till bindestreck, å/ä till a och ö till o, övriga specialtecken bort.
+
+"Haus förvaltningsmodell" blir `haus-forvaltningsmodell.md`.
+
+Slugen används för snapshot-filen och för dokument som hämtats från Slack. En arbetsfil som fanns lokalt först behåller sitt eget namn — `forvaltningsmodellen.md` förblir `forvaltningsmodellen.md` även om canvasen heter "Haus förvaltningsmodell" och snapshotet `haus-forvaltningsmodell.md`. Kopplingen görs i manifestet, inte genom namnlikhet.
+
+Byter dokumentet titel i Slack, behåll den lokala filen och dess namn — döp inte om, eftersom lokala referenser och git-historik då bryts. Uppdatera bara `titel` i manifestet.
+
+Kolliderar två slugar, lägg till dokumentets sista fyra ID-tecken.
+
+## Trevägsjämförelsen
+
+Jämför per sektion mellan tre versioner: **L** (lokal fil), **S** (snapshot) och **F** (fjärr, det Slack innehåller nu).
+
+| L mot S    | F mot S                    | Åtgärd                                 |
+| ---------- | -------------------------- | -------------------------------------- |
+| ändrad     | oförändrad                 | Pusha L till Slack                     |
+| oförändrad | ändrad                     | Skriv F till lokal fil                 |
+| ändrad     | ändrad, men identisk med L | Ingen åtgärd — samma resultat          |
+| ändrad     | ändrad, annorlunda         | **Konflikt** — fråga                   |
+| oförändrad | oförändrad                 | Ingen åtgärd                           |
+| saknas i L | finns                      | Fråga innan radering i Slack           |
+| finns i L  | saknas i F                 | Sektionen är borttagen i Slack — fråga |
+| —          | ny sektion                 | Behåll, skriv till lokal fil           |
+
+Två principer bakom tabellen:
+
+**Radera aldrig utan att fråga.** En sektion som saknas lokalt kan lika gärna bero på att någon i Slack lagt till den efter senaste synken som på att den medvetet tagits bort.
+
+**Identiska ändringar är ingen konflikt.** Har båda sidor råkat göra samma ändring finns inget att lösa.
+
+## Konfliktdialogen
+
+Vid konflikt: avbryt hela pushen. Pusha inte de okonfliktade sektionerna heller — ett halvpushat dokument är svårare att reda ut än ett opushat, och användaren kan vilja ändra sitt lokala utkast efter att ha sett vad någon annan skrivit.
+
+Presentera så här:
+
+```
+Konflikt i "Haus förvaltningsmodell", avsnitt 3 – Principerna
+
+Din lokala version:
+> Risk höjer pris. Det som rör behörighet, pengar eller personuppgifter
+> kostar mer än sin storlek.
+
+I Slack (ändrad av Viktoria Brandel, 14 aug 09:41):
+> Risk påverkar pris. Behörighet, betalning och personuppgifter bär
+> ett större ansvar och prissätts därefter.
+
+Vilken gäller – din, Viktorias, eller ska de vävas ihop?
+```
+
+Ta med vem som ändrat och när där det går att få fram ur kanalhistoriken. Slack ger ingen upphovsinformation per sektion, men Slackbots kanalnotiser ("N made updates to a canvas tab") ger ofta tillräckligt för att namnge personen.
+
+Är flera sektioner i konflikt: visa alla innan du frågar, så att användaren kan bedöma helheten.
+
+## Sektionshantering vid push
+
+`slack_read_canvas` returnerar `section_id_mapping` — en karta från sektions-ID till innehåll. Dessa ID:n ändras vid varje skrivning.
+
+Därför gäller: läs omedelbart före skrivning, i samma tur. Aldrig från minnet, aldrig från en tidigare tur, aldrig från ett tidigare svar i samma konversation.
+
+Skicka alla ändringar i ett enda `slack_update_canvas` med flera poster i `sections`. De tillämpas atomiskt mot samma ögonblicksbild, vilket är både snabbare och säkrare än flera anrop i följd.
+
+Operationstyper:
+
+| `edit_type` | Effekt                       |
+| ----------- | ---------------------------- |
+| `replace`   | Ersätter sektionens innehåll |
+| `append`    | Lägger till efter sektionen  |
+| `prepend`   | Lägger till före sektionen   |
+| `delete`    | Tar bort sektionen           |
+
+Högst 100 operationer per anrop. Behövs fler: dela upp i omgångar och läs om sektions-ID:n mellan varje, eftersom de ändras vid varje skrivning. Säg till användaren att pushen sker i flera steg — atomiciteten gäller bara inom en omgång.
+
+En rubrik och innehållet under den är skilda sektioner. `replace` mot en rubrik ändrar bara rubriken, inte texten under. Ska ett helt avsnitt bytas ut krävs operationer mot både rubriken och dess brödtext. Byter du texten i en rubrik måste rubrikmarkören följa med i `content` — skickar du `Principerna` i stället för `## Principerna` blir rubriken brödtext.
+
+En hel lista eller kryssrutelista är **en** sektion. Att ändra en enda punkt innebär att hela listan skickas som `replace`.
+
+Titelsektionen är dokumentets första. Den tar endast en rad utan radbrytningar, högst 255 byte.
+
+## Nedladdning via underagenter
+
+Starta en agent per dokument, alla i samma tur så de körs parallellt.
+
+Uppdraget till varje agent:
+
+```
+Hämta Slack-canvas <ID> med slack_read_canvas.
+Svaret innehåller dokumentets markdown och en karta över sektions-ID:n.
+Skriv markdown-innehållet oförändrat till <projektmapp>/slack/<kanal>/canvas/<slug>.md
+och en identisk kopia till <projektmapp>/slack/<kanal>/.snapshot/<slug>.md
+Returnera endast en rad JSON: {"id","titel","sokvag","storlek_kb","antal_sektioner"}
+Returnera aldrig dokumentets innehåll.
+```
+
+Sista raden är avgörande. Agentens svar är ett returvärde, inte ett meddelande till en människa — kommer innehållet tillbaka har hela mönstret varit meningslöst, eftersom kostnaden då hamnar i huvudsessionens sammanhang ändå.
+
+Skriv filer med de verktyg som når rätt filsystem: i Cowork mot användarens dator via enhetsbryggan, i Claude Code direkt.
+
+## Historikformat
+
+`historik.md`, nyaste överst, en post per synk:
+
+```markdown
+## 2026-08-14 09:12
+
+**Ändrat sedan 2026-08-13 16:40**
+
+- "Haus förvaltningsmodell" uppdaterad av jonas.landgard 08:01 — avsnitt 4, beslut 3 och 4 låsta
+- Ny canvas: "Paketering befintliga kunder" av Viktoria Brandel
+
+**Diskussion i kanalen**
+
+Viktoria invände mot ordet "förvaltning" i kundkommunikation — signalerar
+underhållsläge när halva erbjudandet är aktiv utveckling. Ligger kvar som
+öppet beslut 1.
+```
+
+Sammanfatta hellre än att citera. Poängen är att en ny session snabbt ska förstå läget, inte att arkivera varje meddelande.
+
+Vid ungefär 50 KB: flytta de äldsta posterna till `historik-arkiv.md` och notera flytten överst i arkivfilen.
+
+## Återställning när snapshot saknas
+
+Saknas `.snapshot/` för ett dokument går konflikter inte att upptäcka. Gissa inte.
+
+Behandla dokumentet som en förstagångssynk:
+
+1. Hämta Slack-versionen till `.snapshot/`.
+2. Finns en lokal fil som avviker: visa skillnaderna och låt användaren avgöra vad som gäller innan något pushas.
+3. Har det aldrig funnits en lokal fil: skriv Slack-versionen till båda platserna.
+
+Det är också skälet till att `git_snapshot` finns som möjlighet — ett git-repo gör snapshot-mappen återställbar efter en olycka.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haus-tech/haus-workflow",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Haus AI workflow CLI for Claude Code.",
   "type": "module",
   "bin": {