faculties 0.14.4

An office suite for AI agents: kanban, wiki, files, messaging, and a GORBIE-backed viewer — all persisted in a TribleSpace pile.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
�"�/G���֎�]��.����I������@M�6��I��%ɭ��̚���2b�"�/G���֎�]��.����Ւ1�j�i�
Sbz2N5"f}C=Yr6������qwiki�"�/G���֎�]��.����y���CM}��ЌEZi�G���Q|x�u?���Mzk����&���)��#��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qk����&���)��#���s�����c\g}��DxM�]g�
�jt�jhk����&���)��#��7.4C3�̀�Ӑ�7T����lh�7T����lh+ɑ���ң�h�;
�5DxM�]g�
�jt�jhy���CM}��ЌEZi�G���Q|x�u?���Mz�"�/G���֎�]��.���
'�B��u�I�|�UxN
v��0F�����experiment�"�/G���֎�]��.���;�9���p��g�l8;DZ�������f�$��archived�"�/G���֎�]��.���bXA�w��Y�AR@dr|����{�����!+�wiki: register tag names�"�/G���֎�]��.���wL��엠٥�C��/��떭�.���critique�"�/G���֎�]��.���}�#r+*���/Ʋ��p���IK��5�usource�"�/G���֎�]��.������J�����9�7	^�������ʫ2�)�	�l���Ǝ`s�(o��p$+(���2|;�.��/��~�0��G���3Gpo�iy���Z1�l���Ǝ`s�(oM���\�4�:�NC���	��vұ$�~��“�m$���kW֠�lEl���Ǝ`s�(o���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2bl���Ǝ`s�(o�y��e�C�AAY<ع��7T����FP�7T����FPl���Ǝ`s�(o��O���(�:<@���䙅�v�7qEk�k�)�n�Vs� ����l���Ǝ`s�(o����$|�hH����[��j��`śF�!�3����K�<$"w�^l���Ǝ`s�(o��x9nԱe�v��bXA�w��Y�AR@dr|����{�����!+��"�/G���֎�]��.����.U���SýYa�5N�
��
c�b����C�paper�"�/G���֎�]��.���@��	��vұ$�~��“�m$���kW֠�lE������}=j̏��H�F��s�#�4����ɠ�T�
��FI9d1��:N������1G��ׇN���d8���H�F��s�#ћ��v	��NQ���E�f���̀�-��9��$:�,^a뼌�����H�F��s�#�h;Q06���������%/AIu��������H��c�	G�&���6l?��H�F��s�#;�9���p��g�l8;DZ�������f�$��r�k㚊�7�@�T���H�F��s�#wL��엠٥�C��/��떭�.���}X���<JX��.��H�F��s�#}�#r+*���/Ʋ��p���IK��5�u�q�p����X�i=9d���H�F��s�#�.U���SýYa�5N�
��
c�b����C��kϐm'��;�[5R��H�F��s�#��
x�;Ґ
3�	�����?	�u_�8C+7�,�䕁z�-) �����H�F��s�#'�B��u�I�|�UxN
v��0F������"�/G���֎�]��.����h;Q06���������%/AIu��������finding�"�/G���֎�]��.�����
x�;Ґ
3�	�����?	�u_�8C+7concept�"�/G���֎�]��.���
�4����ɠ�T�
��FI9d1��:N�����hypothesis�"�/G���֎�]��.���ћ��v	��NQ���E�f���̀�-��9��version�"�/G���֎�]��.���������T�U*�k��i9�2�qR�DP�!v����j4{��D�0����p$+(���2|;�ݎ �<m�v�1*J�r�f���&fiޏ�~�G��j4{��D�0��'/�V�3lM.(�h�_��J�����9�7	^�������ʫ2�)�	��j4{��D�0����H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�j4{��D�0�چ��s�����c\g}��DxM�]g�
�jt�jh�j4{��D�0�ړ�7.4C3�̀�Ӑ�7T����|p�7T����|p�j4{��D�0�ڝ�O���(�:<@������Մ=���%Ck���nq@�0Bw�R�y9��j4{��D�0�ڭ���$|�hH����[��j��`śF�!�3����K�<$"w�^+ɑ���ң�h�;
�5DxM�]g�
�jt�jh�����T�U*�k��i9�2�qR�DP�!v����"�/G���֎�]��.���	R�d�g��[3�M1�h�>rdB����q�r�Ffaculties�"�/G���֎�]��.���-"_m1]�	��D����h�M뛳ä��Hy�Z�DzыZ+�Q�M��� K��p$+(���2|;��tL�����Y�7���S	�)v�),m��ezыZ+�Q�M��� K1pD�Ɛ
y��`��*��J�����9�7	^�������ʫ2�)�	�zыZ+�Q�M��� KM���\�4�:�NC�N:H�pI!����ue�:�,i���:�<��zыZ+�Q�M��� K���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2bzыZ+�Q�M��� K�y��e�C�AAY<ع��7T����8�7T����8zыZ+�Q�M��� K��O���(�:<@�����;W��T0��z���?6��2 DZ&��n/�<zыZ+�Q�M��� K����$|�hH����[��j��`śF�!�3����K�<$"w�^zыZ+�Q�M��� K��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��.����N:H�pI!����ue�:�,i���:�<��-x��I��׆������H�F��s�#�b���|���)�~�[z��,J;}l{j��j�>U�hX��m_��
�^���H�F��s�#R�d�g��[3�M1�h�>rdB����q�r�F_�G�����gL ,��m��F��zG��	����S�@��џ�^N"��}z�aJ�l�T�Zg_�G�����gL ,��x���y%1��7-��_>��i���j���!�b�Z���[&鍥vN_�G�����gL ,������s�����F�Q�1G��ׇN���d8�_�G�����gL ,������s�����F�Q-x��I��׆����_�G�����gL ,������s�����F�Q>U�hX��m_��
�^�_�G�����gL ,������s�����F�Q���O�5���
��)]/�_�G�����gL ,���y��e�C�AAY<ع��7T�����؀7T������_�G�����gL ,����V�t�8�O_�h��o3v�΃��:#g���:���O�5���
��)]/���H�F��s�#Y&�	bD�T�:����f�EGY;��d}{��"�/G���֎�]��.���
Y&�	bD�T�:����f�EGY;��d}{�onboarding�"�/G���֎�]��.���.�@��џ�^N"��}z�aJ�l�T�Zg= How Faculties Work

Faculties are self-contained `rust-script` scripts living in a
`faculties/` checkout (the canonical upstream is
#link("https://github.com/triblespace/faculties")[github.com/triblespace/faculties]).
Each one is a CLI that reads and writes a TribleSpace pile via
the `triblespace` crate.

== Mental model

  - One faculty = one cognitive verb (`compass` for goals,
    `wiki` for fragments, `files` for archived artefacts,
    `local_messages` for direct messages, etc.)
  - Each faculty owns a *branch* in the pile (`compass`,
    `wiki`, `files`, …) and writes its own commits there.
  - Branches are merged independently; touching `compass` doesn't
    invalidate `wiki`.
  - All scripts honour `PILE=/path/to/self.pile` as an environment
    variable — set it once per session and skip `--pile` on every
    call.

== Discovery

`ls $(dirname $(which wiki))` (or `ls path/to/faculties/`
if you haven't put them on PATH yet) shows what's available.
Each faculty supports `--help` listing its subcommands;
subcommands take their own `--help` for argument detail.

== Why this shape

The agent acts through shell commands and observes concrete
output. A faculty is the smallest possible "verb you can run from
a shell that produces a durable side effect." The pile is the
single source of truth — everything the agent thinks, decides, or
produces accretes there as content-addressed blobs.

This is the *shell-first causality* design: model speaks to the
world via shell, the world speaks back via stdout, and the pile
remembers everything between turns.
�"�/G���֎�]��.�����i���j���!�b�Z���[&鍥vNHow Faculties Work�"�/G���֎�]��.�����,�NO��I
�j��:��8T5�-1v9���wiki create�"�/G���֎�]��.���	�b���|���)�~�[z��,J;}l{j��j�bootstrap�"�/G���֎�]��.����26����.G€)�޵�$�����M9�S_9��P�T7�qaJK���1��p$+(���2|;�(F#f�HϽ��7�x_K,�{"��(8@����W�T7�qaJK���1'/�V�3lM.(�h�_-"_m1]�	��D����h�M뛳ä��Hy�Z�D�T7�qaJK���1��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�T7�qaJK���1���s�����c\g}��DxM�]g�
�jt�jh�T7�qaJK���1��7.4C3�̀�Ӑ�7T����� �7T����� �T7�qaJK���1��O���(�:<@�����DpA�
���+HH
�A�|��¡?ij��T7�qaJK���1����$|�hH����[��j��`śF�!�3����K�<$"w�^+ɑ���ң�h�;
�5DxM�]g�
�jt�jh26����.G€)�޵�$�����M9�S_9��P�"�/G���֎�]��.���T�����$=�v�t��J�
�7�e`n��Wiki Fragment Style Guide�"�/G���֎�]��.���Vf�t�B��z|Z	������<�m����X�m�= Wiki Fragment Style Guide

A wiki fragment captures one thing worth keeping past this turn.
Atomic, cross-linked, written in typst, rendered by GORBIE.

== Authoring

  - `wiki create "Title" "@/tmp/body.typ" --tag <tag>...` —
    create a new fragment from a file.
  - `wiki create "Title" "@-" --tag <tag>` — read body from
    stdin (useful in pipes).
  - `wiki edit <ID> @/tmp/body.typ` — bump a new version of an
    existing fragment.
  - `wiki lint` — lint markdown→typst, expand short ids,
    rebuild the `links_to` index.
  - `wiki check` — diagnose orphan fragments, broken links,
    truncated ids, missing format tags.

== One claim per fragment

If you find yourself writing "and another thing", split. The
fragment's title should fit on one line and accurately describe
its single claim. Cross-link by reference (`wiki:<full-id>`).

== Tagging

Tags are how you find related fragments later. `--tag design`,
`--tag triblespace`, `--tag onboarding`, etc. Tags are minted
on first use; pick consistent labels (`#design` not
`#desing`).

== Typst, not markdown

Bodies are typst (`.typ`-shaped). The wiki faculty parses them on
create/edit and rejects malformed input. GORBIE renders them with
math mode, code blocks, links. Avoid raw HTML; typst markup beats
it everywhere.

== When NOT to use the wiki

  - Per-task working notes that the conversation already covers
    — the moment-history captures those.
  - Status of in-flight work — that goes in compass goals.
  - Binary artefacts — `files add` puts them content-addressed
    in the pile and gives you a `files:<hash>` reference.
�"�/G���֎�]��.������ѯ�԰߅ۣ>m��_te3:�y�I��>�EE=��h#�V��p$+(���2|;�jk%�4�h$ç�l���$�Y� ���O5mxn��>�EE=��h#�V1pD�Ɛ
y��`��*-"_m1]�	��D����h�M뛳ä��Hy�Z�D��>�EE=��h#�VM���\�4�:�NC��&E�z	�(�"��
N����@�Mm�@���d���>�EE=��h#�V���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��>�EE=��h#�V�y��e�C�AAY<ع��7T���)��7T���)���>�EE=��h#�V��O���(�:<@����o2>_G�'�?��d��U���	MG	�0�.���5��>�EE=��h#�V����$|�hH����[*}Ay\�EAԚk�	�wӶ]Șȶ�O�X�`��>�EE=��h#�V��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��.���@�&E�z	�(�"��
N����@�Mm�@���d�(|����t�	��<��m��F��zG��	����Sf�t�B��z|Z	������<�m����X�m�(|����t�	��<��x���y%1��7-��_>T�����$=�v�t��J�
�7�e`n��(|����t�	��<������s�����F�Q�1G��ׇN���d8�(|����t�	��<������s�����F�Q-x��I��׆����(|����t�	��<������s�����F�Qx��T:l��#Gd�ï�(|����t�	��<������s�����F�Q���O�5���
��)]/�(|����t�	��<���y��e�C�AAY<ع��7T���("��7T���("�(|����t�	��<����V�t�8�O_�h��!!�O���Ou=y�N��x��T:l��#Gd�ï���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�"�/G���֎�]��.����[O.�DK6r^�bI)<�����f�C���!2��x�ק��ӓ7�;��p$+(���2|;�?�+@���.�QM�/v/8�e�B�0�)�����x�ק��ӓ7�;'/�V�3lM.(�h�_���ѯ�԰߅ۣ>m��_te3:�y�I��x�ק��ӓ7�;��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q��x�ק��ӓ7�;���s�����c\g}��DxM�]g�
�jt�jh��x�ק��ӓ7�;��7.4C3�̀�Ӑ�7T���*��7T���*���x�ק��ӓ7�;��O���(�:<@���䙤~�=�����\c���J��4��e�/)P�T'�+L��x�ק��ӓ7�;����$|�hH����[*}Ay\�EAԚk�	�wӶ]Șȶ�O�X�`+ɑ���ң�h�;
�5DxM�]g�
�jt�jh[O.�DK6r^�bI)<�����f�C���!2�"�/G���֎�]��.���[̾1��y��!�v1(y�
g`�IG�m?KIT;	�l�Pۧ6�q�T���p$+(���2|;ƕ�%�|������6�U�Z�s��[�`2��	�l�Pۧ6�q�T�1pD�Ɛ
y��`��*���ѯ�԰߅ۣ>m��_te3:�y�I	�l�Pۧ6�q�T�M���\�4�:�NC�����:��=�7���BtB`���d�=�7��`�	�l�Pۧ6�q�T����ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b	�l�Pۧ6�q�T��y��e�C�AAY<ع��7T���q��7T���q�	�l�Pۧ6�q�T���O���(�:<@������
U���k4�Y4���g5,�yraY_�UE�g�	�l�Pۧ6�q�T�����$|�hH����[<
A;��N���PhG���
�b��k~�8��3��	�l�Pۧ6�q�T���x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��.���V*�]D�ĝ�0�"�x��No)!��	��1Compass Goals Workflow�"�/G���֎�]��.���O1}X�A�{�K&]�rh%�`��c�x�[$�compass�"�/G���֎�]��.����ɪ�����\���\W�h�˯���H�P�dF�l= Compass Goals Workflow

`compass` is the goal/task tracker. Use it instead of
Claude Code's TaskCreate/TaskUpdate — compass goals persist
across sessions and merge between agents; the harness's task
list does neither.

== Statuses

  - `todo` — queued, not started
  - `doing` — actively in progress
  - `blocked` — waiting on something external
  - `done` — finished, with an outcome note

Stick to those four unless there's a strong reason to introduce
another.

== Daily flow

  + `compass list` — see your active goals
  + Pick one, `compass status <id> doing` — claim it
  + Add notes as you decide things: `compass note <id> "..."`
  + When finished: `compass status <id> done` then a final
    note recording the outcome
  + Repeat

== Hierarchy

`compass goal-create --parent <id>` creates a sub-goal. Use
this when a goal naturally breaks into 3+ steps you'll want to
track separately. Don't sub-goal trivial steps — the conversation
itself is the right level for "and now do X".

== Tags

Compass tags work like wiki tags. Common ones:
`#meta`, `#bootstrap`, `#parking` (see Scope Control below),
plus project-specific tags (`#liora` in the Liora project,
`#deploy` for ops work, etc.).

== Scope control: parking lot

Mid-task ideas that would take >2 minutes go in compass with
a `#parking` or `#later` tag. Then *return to the current goal*.
Near the end of a session, do a parking-lot sweep: promote
0–2 parked items to active, leave the rest.

The parking discipline keeps the agent from infinitely-context-
switching and producing nothing. Compass is the queue; the
conversation is the executor.

== When NOT to use compass

  - In-conversation TodoWrite-style step planning is fine for
    "the next 20 minutes" — compass is for goals you'd want to
    pick up later, including in a future session.
  - Pure scratch state ("what was I about to do") — that's the
    conversation itself.
�"�/G���֎�]��.���@����:��=�7���BtB`���d�=�7��`�KS��3��?P��չ?}m��F��zG��	����Sɪ�����\���\W�h�˯���H�P�dF�lKS��3��?P��չ?}x���y%1��7-��_>V*�]D�ĝ�0�"�x��No)!��	��1KS��3��?P��չ?}����s�����F�Q�1G��ׇN���d8�KS��3��?P��չ?}����s�����F�Q-x��I��׆����KS��3��?P��չ?}����s�����F�Q�um|�DJG��uC�;zKS��3��?P��չ?}����s�����F�Q���O�5���
��)]/�KS��3��?P��չ?}�y��e�C�AAY<ع��7T���p3X�7T���p3XKS��3��?P��չ?}��V�t�8�O_�h��h7��5�!tzZg]��um|�DJG��uC�;z��H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$��"�/G���֎�]��.������(�L"=6���ƧEpy�`�B�5Qj�s0����H�������Id9���p$+(���2|;�s!�*�����e�%
e��v6K�}9��w��]���H�������Id9�'/�V�3lM.(�h�_[̾1��y��!�v1(y�
g`�IG�m?KIT;��H�������Id9���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q��H�������Id9����s�����c\g}��DxM�]g�
�jt�jh��H�������Id9���7.4C3�̀�Ӑ�7T���r�`�7T���r�`��H�������Id9���O���(�:<@�����=0଩��-۠��N��*�S#�����H{�L��H�������Id9�����$|�hH����[<
A;��N���PhG���
�b��k~�8��3��+ɑ���ң�h�;
�5DxM�]g�
�jt�jh��(�L"=6���ƧEpy�`�B�5Qj�s0���"�/G���֎�]�/����RM_�u�f�%
 'y`���I��C#l1��^^ᵙ�b'#,�`���p$+(���2|;��ZH�~JYj��F������n�{D�~�^^ᵙ�b'#,�`�1pD�Ɛ
y��`��*[̾1��y��!�v1(y�
g`�IG�m?KIT;^^ᵙ�b'#,�`�M���\�4�:�NC����&(����`�_�~���ƻ�V�&?l��o^^ᵙ�b'#,�`����ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b^^ᵙ�b'#,�`��y��e�C�AAY<ع��7T���s��7T���s�^^ᵙ�b'#,�`���O���(�:<@���䙎^�H��՝�I��-4�jh��&�SQ�s^	f=n^^ᵙ�b'#,�`�����$|�hH����[��Uޙg��Y��I�Oo{����֩�dj^^ᵙ�b'#,�`���x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�/���	4h���F�n~��u��c8`]i*k�YyI�subagents�"�/G���֎�]�/����C{*���!�WI���,/��~$�P��L
W���= When to Use Codex (and When Not To)

Codex is a separate agent runtime you can launch from your shell.
Treat yourself as the *control plane*, codex as the *data plane*:
you supervise, plan, integrate; codex grinds.

== When codex earns its weight

  - Long literature trawls (read 30 papers, summarise each).
  - Multi-round experiments (run a benchmark, tune a knob, rerun,
    compare).
  - Parallelisable code generation (port 12 similar files).
  - Anything where the *token cost of reading* dominates.

Codex has abundant token quota and no stateful supervision. You
have `/loop` and limited quota. Match the work to the tool.

== When codex is overhead

  - Short tasks (under 10 min wall-clock).
  - Tasks where supervising codex's output costs more time than
    doing it yourself.
  - Tasks where the answer is already in your context — codex
    would just re-derive it.

== Launch pattern

```sh
codex exec --dangerously-bypass-approvals-and-sandbox \
  --skip-git-repo-check \
  "$(cat /tmp/prompt.txt)" \
  < /dev/null > /tmp/log 2>&1
```

Run via Bash with `run_in_background: true` and *no trailing `&`*.
The `< /dev/null` is *required* — codex blocks on stdin
indefinitely otherwise. The `&` is *forbidden* — it detaches
codex from the shell and fires the task-completion notification
instantly.

== Prompt discipline

  - Inline all context (one paragraph, no "see file X").
  - State the specific deliverable path (`/tmp/codex_outputs/...`)
    and demand a heredoc.
  - Set a budget ("~15 min, stub if you run out").
  - Wrap the resulting `.typ` file as a wiki fragment yourself —
    don't have codex invoke `wiki create` directly. Sanity-check
    is easier from your side first.
�"�/G���֎�]�/���#��}��B�zr�]]�biP+�����ӡ���When to Use Codex (and When Not To)�"�/G���֎�]�/����;��1���Ta3����ȱ58/D�D�k�FTcodex�"�/G���֎�]�/�������&(����`�_�~���ƻ�V�&?l��o�3�XsP�jA?���f*��H�F��s�#�;��1���Ta3����ȱ58/D�D�k�FT��g��J�r��	��m��F��zG��	����SC{*���!�WI���,/��~$�P��L
W�����g��J�r��	��x���y%1��7-��_>��}��B�zr�]]�biP+�����ӡ����g��J�r��	������s�����F�Q�3�XsP�jA?���f*��g��J�r��	������s�����F�Q�1G��ׇN���d8Ϧ�g��J�r��	������s�����F�Q-x��I��׆���զ�g��J�r��	������s�����F�Q���O�5���
��)]/���g��J�r��	������s�����F�Q�Z�&��oY���X¦�g��J�r��	���y��e�C�AAY<ع��7T���r���7T���r����g��J�r��	����V�t�8�O_�h��;b�P�`�l�����~�Z�&��oY���X���H�F��s�#4h���F�n~��u��c8`]i*k�YyI��"�/G���֎�]�/������ye3�+���F�9WG1�����e*�<NKU�}���Y�fǮ������p$+(���2|;�i��u4��@�����kL�bXXb-";s~`�?CU�}���Y�fǮ����'/�V�3lM.(�h�_�RM_�u�f�%
 'y`���I��C#l1��U�}���Y�fǮ������H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qU�}���Y�fǮ�������s�����c\g}��DxM�]g�
�jt�jhU�}���Y�fǮ������7.4C3�̀�Ӑ�7T���uFp�7T���uFpU�}���Y�fǮ������O���(�:<@����BsG-f6/�Z��kW�(c�L���u��b^mg�U�}���Y�fǮ��������$|�hH����[��Uޙg��Y��I�Oo{����֩�dj+ɑ���ң�h�;
�5DxM�]g�
�jt�jh��ye3�+���F�9WG1�����e*�<NK�"�/G���֎�]�/����@�����(
�5�uS,X�%�u�T/�0Y!l���w�]	Z"
�"x���H�F��s�#���t��/n-�_�r�c����������F�V��_.������ڙ�0ł��m��F��zG��	����SY��KS�GC�Y�J�ע[��V
���*揤�?+�_.������ڙ�0ł��x���y%1��7-��_>+LS<K6�%�'�;xY\���x{/;46P�a �_.������ڙ�0ł������s�����F�Ql���w�]	Z"
�"x�_.������ڙ�0ł������s�����F�Q�1G��ׇN���d8�_.������ڙ�0ł������s�����F�Q-x��I��׆����_.������ڙ�0ł������s�����F�Q���O�5���
��)]/�_.������ڙ�0ł������s�����F�Q�=3�%F��e�=e�_.������ڙ�0ł���y��e�C�AAY<ع��7T���v;��7T���v;�_.������ڙ�0ł����V�t�8�O_�h���C�W�D��r����=3�%F��e�=e���H�F��s�#J�mM#�D��{��}8o��&G�����g���"�/G���֎�]�/���+LS<K6�%�'�;xY\���x{/;46P�a �Work As Its Own Ledger�"�/G���֎�]�/���	J�mM#�D��{��}8o��&G�����g��principle�"�/G���֎�]�/����Y��KS�GC�Y�J�ע[��V
���*揤�?+�= Work As Its Own Ledger

The design principle behind faculties: provenance, versioning,
and history must be *exhaust* from the work, not separate
obligations on top of it.

== The test

Is the bookkeeping a side effect of the workflow, or a separate
step? If separate, redesign until it's not.

  - Git works because branching saves your ass while you're
    coding. The history is exhaust.
  - Systems that require "documentation steps" fail. The agent
    forgets, the human forgets, the docs drift.

== How faculties embody this

  - `wiki create` *is* the writing. The fragment is durable
    the moment it's saved.
  - `compass status <id> doing` *is* the claim. No separate
    "log that I started this".
  - `files add <path>` *is* the archive step. The handle is
    the citation.
  - Pile commits *are* the version history. No separate
    snapshotting.

== The corollary: don't write throwaway markdown

Free-floating `.md` plan files in repos are a red flag. They:

  - Don't merge between agents.
  - Don't show up in `wiki list`.
  - Aren't content-addressed.
  - Drift the moment you stop editing them.

If the content is worth keeping past this turn, it goes in the
pile (wiki / compass / files). If it's not, the conversation
itself is enough.

== Further reading

The bootstrap-pile design conversation walking through how this
principle drives the onboarding system itself lives in the
project that ships this pile (search for "Bootstrap Pile" in
the local pile, or in the `faculties` repo's design notes).
�"�/G���֎�]�/���������|%��B}I#��]&q��]S4��c��s�k��byڎ�^�5��p$+(���2|;�T;��[��
���I���
��þy����PB��s�k��byڎ�^�51pD�Ɛ
y��`��*�RM_�u�f�%
 'y`���I��C#l1����s�k��byڎ�^�5M���\�4�:�NC�@�����(
�5�uS,X�%�u�T/�0Y!��s�k��byڎ�^�5���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��s�k��byڎ�^�5�y��e�C�AAY<ع��7T���w��7T���w���s�k��byڎ�^�5��O���(�:<@���䙫x�5�_��w1?=;�/���՚���%���F�C��s�k��byڎ�^�5����$|�hH����[e9݁����l[��z+h�����:� }@��'��s�k��byڎ�^�5��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�/������t��/n-�_�r�c����������F�V��design�"�/G���֎�]�/�����X�@�ቧ�c��t�l+�4U��e%���C����o�/*�B������p$+(���2|;�wٛ�Fk�yhS�V�gCQ�f�m(�,-8��bC����o�/*�B����'/�V�3lM.(�h�_������|%��B}I#��]&q��]S4��cC����o�/*�B������H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qC����o�/*�B���ņ��s�����c\g}��DxM�]g�
�jt�jhC����o�/*�B���œ�7.4C3�̀�Ӑ�7T���x���7T���x��C����o�/*�B���ŝ�O���(�:<@����y%��\��[WF�n�H�>?|M�=S�A�>O�;C����o�/*�B���ŭ���$|�hH����[e9݁����l[��z+h�����:� }@��'+ɑ���ң�h�;
�5DxM�]g�
�jt�jh�X�@�ቧ�c��t�l+�4U��e%����"�/G���֎�]�1/���:��R������urH�V?�����:`�H	4Tool Selection: Faculties First�"�/G���֎�]�1/���	R�k,��f�u�z{\:�J���˾��	��t)�reference�"�/G���֎�]�1/����T��ʶ��<��Z�u�j�8����'���= Tool Selection: Faculties First

A quick lookup for "which tool do I reach for here?"

== Goals and tasks

  - *Use* `compass goal-create` / `status` / `note`.
  - *Don't use* the harness's TaskCreate / TaskUpdate for
    persistent goals — those vanish at end of session.
  - *Do use* TaskCreate inline within a single conversation when
    you need a step-tracker for "the next 20 minutes". Compass
    is for "still on my plate next week".

== Knowledge fragments

  - *Use* `wiki create / edit / lint`.
  - *Don't use* free-floating `.md` files in repos.
  - *Exception*: when a downstream consumer needs the file at a
    specific path (a crate's `CHANGELOG.md`, a `book/src/`
    chapter rendered by mdbook), then `.md` is correct.

== Files (PDFs, datasets, binaries)

  - *Use* `files add <path>`. Returns a `files:<hash>` handle
    you cite from wiki fragments.
  - *Don't use* `/tmp` for anything you'll want past this turn.
  - *Don't commit* binaries to repos — they bloat the history.

== Direct messages between agents

  - *Use* `local_messages` for in-place agent-to-agent
    messaging (append-only, with read acknowledgements).
  - For shared knowledge between two agents: a wiki fragment
    they both query is usually better than a message.

== Subagents

  - *Use* codex for parallelisable / token-heavy work where
    supervision overhead is amortised (see the "When to Use
    Codex" bootstrap fragment).
  - *Use* the harness's Agent tool for short focused
    sub-tasks that share your conversational context (e.g.
    "Explore: find files matching pattern X").
  - *Don't use* either for tasks under ~5 min — direct execution
    beats subagent-launch overhead.

== Plans

  - *Prefer* in-conversation plans + compass goals.
  - *Don't* write `PLAN.md` / `TODO.md` files in repos. They
    accrete stale sections.
  - *Exception*: an explicit user request for a written plan
    document, where the user wants to review before execution.
�"�/G���֎�]�1/����[=d�����q������L���i��5�+��W\�qy���N&����p$+(���2|;Ǝ����y+/�"�1�?�[1n6P�'x
D��W\�qy���N&��1pD�Ɛ
y��`��*������|%��B}I#��]&q��]S4��c��W\�qy���N&��M���\�4�:�NC��}�bǸ^����B�0�]>��j���f�f+u���W\�qy���N&�ʈ��ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��W\�qy���N&�ʛy��e�C�AAY<ع��7T����h(�7T����h(��W\�qy���N&�ʝ�O���(�:<@����ǪX�ËƱ��|��m-��f#�81N��"ʅ�p���W\�qy���N&�ʭ���$|�hH����[w����::T�|��Je=)��P/��(6��٧�’���W\�qy���N&�ʵ�x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�1/�����}�bǸ^����B�0�]>��j���f�f+u�4����g�5L$����m��F��zG��	����ST��ʶ��<��Z�u�j�8����'���4����g�5L$����x���y%1��7-��_>:��R������urH�V?�����:`�H	44����g�5L$��������s�����F�Q�1G��ׇN���d8�4����g�5L$��������s�����F�Q-x��I��׆����4����g�5L$��������s�����F�QH(Fy}�c��Kvj�Ñ4����g�5L$��������s�����F�Q���O�5���
��)]/�4����g�5L$��������s�����F�Q�T�����n!����~e4����g�5L$�����y��e�C�AAY<ع��7T�������7T������4����g�5L$������V�t�8�O_�h��WQ�p�0�l�O�6�+pH(Fy}�c��Kvj�Ñ��H�F��s�#R�k,��f�u�z{\:�J���˾��	��t)��T�����n!����~e��H�F��s�#��F3@�<���$�ݧ�sL�����}"itzysh�"�/G���֎�]�1/�����F3@�<���$�ݧ�sL�����}"itzyshtools�"�/G���֎�]�1/����f�۾]�n�z�'��W��8���UA/�f�E�X`�V���$i����p$+(���2|;�g�6s�R
5�]:�me)|_�h�Xe�I���X`�V���$i��'/�V�3lM.(�h�_�[=d�����q������L���i��5�+�X`�V���$i����H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�X`�V���$i�����s�����c\g}��DxM�]g�
�jt�jh�X`�V���$i����7.4C3�̀�Ӑ�7T����H��7T����H��X`�V���$i����O���(�:<@����Ս�xU��(��d�8v,	�΁��lx����X`�V���$i������$|�hH����[w����::T�|��Je=)��P/��(6��٧�’�+ɑ���ң�h�;
�5DxM�]g�
�jt�jhf�۾]�n�z�'��W��8���UA/�f�E�"�/G���֎�]�J/���
7Ͼ��tG8� ��"
���:]L+��%start-here�"�/G���֎�]�J/����ifô�6����S�`��秹;n+3��GhUH�ξI�Д�����p$+(���2|;�*:��Dn�>K=\Q��������Q�u���S	�UH�ξI�Д���1pD�Ɛ
y��`��*�[=d�����q������L���i��5�+UH�ξI�Д���M���\�4�:�NC�ţ��_f�c�����|�.�z��1]���;p*BUH�ξI�Д��ӈ��ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2bUH�ξI�Д��ӛy��e�C�AAY<ع��7T���l��7T���l�UH�ξI�Д��ӝ�O���(�:<@����-���b��*_��"a"p�ۙ�Z�H�'.UH�ξI�Д��ӭ���$|�hH����[߂N:}@��U
��i1��j��GK������UH�ξI�Д��ӵ�x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�J/�����5x�0�A8ݺ�r9��w�0`��(�aB;�f!楸= Getting Started: Your First Hour

Welcome. You're an AI agent landing in this workspace for the
first time. This fragment walks you through orienting yourself
and starting to do work.

== Step 1: orient your environment (10 min)

  + `ls $(dirname $(which wiki))` — see what faculties exist
    on your PATH (or `ls path/to/faculties/` if you haven't put
    them on PATH yet).
  + `wiki list --tag bootstrap` — see all the onboarding
    fragments (this one + the foundation + per-faculty fragments).
  + `compass list` — see active goals.
  + `compass list todo` (filter to a tag with `--tag bootstrap`
    if there are non-onboarding goals mixed in) — see your
    bootstrap tasks.

== Step 2: project-specific context

If you're inheriting an existing project (vs. starting fresh),
look for a `wiki --pile ./self.pile show <id>` "letter from
the previous instance" or similar onboarding handoff in the
local pile — projects like Liora seed one as the first thing
to read. `wiki search "letter"` or `wiki list --tag
onboarding` from your local pile should surface it.

If there isn't one, skip this step.

== Step 3: do the bootstrap goals (30 min)

The compass has a handful of `#bootstrap`-tagged goals walking
you through hands-on faculty use:

  - mint an id with `trible genid`
  - create your first wiki fragment
  - link two fragments
  - archive a file
  - run `wiki lint` and `wiki check`
  - add a compass note to one of your goals

Working through these gives you the muscle memory the docs
can't.

== Step 4: pick up real work (15 min)

  + `compass list doing` — anything in flight you should
    take over?
  + If nothing's in flight, ask the user (look up their handle
    via `relations list` if you don't already know it) what
    they need next.

== If you get stuck

  - `wiki search <keyword>` — full-text across all
    fragments.
  - Re-run any faculty with `--help`.
  - Check `CLAUDE.md` (project root) for project-specific
    conventions that override defaults.
  - Ask the user.

== Sibling fragments

`wiki list --tag bootstrap` enumerates the onboarding
fragments by id and title. The set covers two shapes:

*Foundations* — read first if you've never used faculties:

  - "How Faculties Work" — the faculty model and shell-first
    causality
  - "Wiki Fragment Style Guide" — typst, atomic, cross-linked
  - "Compass Goals Workflow" — todo / doing / blocked / done
  - "When to Use Codex (and When Not To)" — control-plane vs
    data-plane
  - "Work As Its Own Ledger" — the principle behind faculties
  - "Tool Selection: Faculties First" — quick-lookup table for
    "which tool here?"
  - "Getting Started: Your First Hour" (this fragment)

*Specific faculties* — read when you reach for one:

  - "Files Faculty: Archiving and Citing Artefacts"
  - "Teams: Capability-Based Membership"
  - "Local Messages: Agent-to-Agent Direct Messaging"
  - "Orient: The Situation-Snapshot Faculty"
  - "Relations: People and Handle Mappings"
  - "Web: Search and Fetch Through Provider APIs"

*Recipes* — chained-faculty workflows for common tasks:

  - "Recipe: Research Workflow" — compass → web → files
    → wiki, end-to-end for "investigate something and write
    it up"
  - "Recipe: Multi-Agent Coordination" — relations +
    local_messages + orient + compass for two-agent handoffs
    without race conditions or silent drops
  - "Recipe: Auth Setup for a Multi-Agent Team" — `trible
    team` + `pile net` for bootstrapping capability auth
    across two machines so the relay accepts both peers

Read the foundations in any order; each stands alone. Tool
Selection is the densest if you want a single-page reference.
For "where was I?" at session start, run `orient show`
before reading anything.
�"�/G���֎�]�J/���@ţ��_f�c�����|�.�z��1]���;p*B>:�U!]�Zb��,�t�m��F��zG��	����S�5x�0�A8ݺ�r9��w�0`��(�aB;�f!楸>:�U!]�Zb��,�t�x���y%1��7-��_>���z���]:n��N�i��'<�����>:�U!]�Zb��,�t�����s�����F�Q�1G��ׇN���d8�>:�U!]�Zb��,�t�����s�����F�Q-x��I��׆����>:�U!]�Zb��,�t�����s�����F�Qh>r=G -Vt-��>:�U!]�Zb��,�t�����s�����F�Q���O�5���
��)]/�>:�U!]�Zb��,�t��y��e�C�AAY<ع��7T�����7T�����>:�U!]�Zb��,�t���V�t�8�O_�h��B� %5->�(v�I�/h>r=G -Vt-����H�F��s�#7Ͼ��tG8� ��"
���:]L+��%�"�/G���֎�]�J/��� ���z���]:n��N�i��'<�����Getting Started: Your First Hour�"�/G���֎�]�J/����a0W�x���c6�lO�B��਷�tL��Ū2�ўs�F�����h���p$+(���2|;�o�2�5sҊ.ܶ֠�@5)(��_��r���7��ўs�F�����h�'/�V�3lM.(�h�_�ifô�6����S�`��秹;n+3��Gh�ўs�F�����h���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�ўs�F�����hʆ��s�����c\g}��DxM�]g�
�jt�jh�ўs�F�����hʓ�7.4C3�̀�Ӑ�7T���&(�7T���&(�ўs�F�����hʝ�O���(�:<@�����K��}+]$��@{kk�!�B��!��V�g�m�e�ўs�F�����hʭ���$|�hH����[߂N:}@��U
��i1��j��GK������+ɑ���ң�h�;
�5DxM�]g�
�jt�jha0W�x���c6�lO�B��਷�tL��Ū2�"�/G���֎�]�j/����v<~JJ,�'#��ZK�
��H�am�j��8�P��2W6aÕ o��p$+(���2|;���������O�5Q�C?e醊.�]Ov䀦u�8�P��2W6aÕ o1pD�Ɛ
y��`��*�ifô�6����S�`��秹;n+3��Gh�8�P��2W6aÕ oM���\�4�:�NC�~e�b���Q�2y��u3�ܣ9b�mj�I]A�8�P��2W6aÕ o���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�8�P��2W6aÕ o�y��e�C�AAY<ع��7T����ٸ�7T����ٸ�8�P��2W6aÕ o��O���(�:<@����Rr3GP.1a2" �v
��)v�F�$ե�����8�P��2W6aÕ o����$|�hH����[/#y|����0	�<�(��F���\�)Mj���8�P��2W6aÕ o��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�j/���-|���k�����]�+߿B�������!Y?aFiles Faculty: Archiving and Citing Artefacts�"�/G���֎�]�j/���@~e�b���Q�2y��u3�ܣ9b�mj�I]A��ug�%J�����*�m��F��zG��	����S�{*l��է�%���4���o\I�&'�[��5��ug�%J�����*�x���y%1��7-��_>|���k�����]�+߿B�������!Y?a��ug�%J�����*�����s�����F�Q�1G��ׇN���d8ς�ug�%J�����*�����s�����F�Q-x��I��׆���Ղ�ug�%J�����*�����s�����F�Q���O�5���
��)]/���ug�%J�����*�����s�����F�Q�H�r��M;G��(]�h���ug�%J�����*��y��e�C�AAY<ع��7T�����X�7T�����X��ug�%J�����*���V�t�8�O_�h���tq`�\�Ƭ |�
�H�r��M;G��(]�h���H�F��s�#�΅B�I++|E<�,G�
��ݵ�L�̑���"�/G���֎�]�j/�����{*l��է�%���4���o\I�&'�[��5= Files Faculty: Archiving and Citing Artefacts

`files` is the content-addressed file store. Use it for any
binary or large-text artefact you'll want to cite from a wiki
fragment later: PDFs, datasets, screenshots, codex output dumps,
downloaded papers.

== Why this exists

  - The pile is the single source of truth — putting an artefact
    in `/tmp` means it's gone next session.
  - Content-addressing means the same bytes always hash to the
    same handle. Two agents with the same paper in their files
    branch can cite the same `files:<hash>` and the cite resolves
    on either side.
  - Wiki fragments cite files by handle, not by path; an
    archived file is durable across machines, sessions, and
    pile renames.

== Usage

```sh
# Archive a single file
files add ~/Downloads/some_paper.pdf
# → files:<hash>   (use this handle in wiki fragments)

# Fetch from a URL straight into the pile (avoids the tmp step)
files fetch https://arxiv.org/pdf/2305.12345.pdf

# List what you've archived
files list

# Search by name or tag
files search "succinct"
files list --tag paper

# Pull a file back out
files get <hash> ~/Desktop/recovered.pdf

# Pipe to stdout (works with binary)
files get <hash> @- > /tmp/check.pdf
```

== Tagging and search

  - `files tag <hash> <tagname>` adds a tag.
  - Tags compose: a paper might be tagged `paper`, `arxiv`,
    `compression`, `benchmark`. Each new tag is queryable
    independently.
  - Tag conventions: keep tags lowercase, short, durable.
    Topic tags (`compression`, `auth`) live longer than
    project tags (`liora-q2-experiment`).

== When NOT to use files

  - Source code under git — that's already content-addressed
    by the commit hash.
  - Tiny text snippets — those go in wiki fragments directly.
  - Anything you'd want to read with `wiki show` later —
    fragments render in GORBIE; files don't.

== Citation pattern

In a wiki fragment:

```typ
The convergence rate proof appears in
Mezard 2009 (`files:<hash>`) section 4.
```

GORBIE renders this as a clickable link that opens the
archived PDF in a viewer. The `files:<hash>` form is also
greppable from a terminal, which beats hex-only handles.
�"�/G���֎�]�j/����΅B�I++|E<�,G�
��ݵ�L�̑��files�"�/G���֎�]�j/������ŀ��i@z���'k�XwPP���X��˼5�럊�;�
l �4R����p$+(���2|;Ƃ�^�;��*�a"�8e~�ڮ��du��1AN�럊�;�
l �4R��'/�V�3lM.(�h�_�v<~JJ,�'#��ZK�
��H�am�j��럊�;�
l �4R����H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�럊�;�
l �4R�����s�����c\g}��DxM�]g�
�jt�jh�럊�;�
l �4R����7.4C3�̀�Ӑ�7T����{��7T����{��럊�;�
l �4R����O���(�:<@����cǔ`P?�2���Ӳ̳�=��Y�9M��k�� �럊�;�
l �4R������$|�hH����[/#y|����0	�<�(��F���\�)Mj��+ɑ���ң�h�;
�5DxM�]g�
�jt�jh��ŀ��i@z���'k�XwPP���X��˼5�"�/G���֎�]��/���"$���f��t���%�X����#E����m��Teams: Capability-Based Membership�"�/G���֎�]��/���&���ԟ#[RM�d���|c�jD�#Ћ�LK~`��6�ȏ�W=��/��p$+(���2|;Ʃ}�<�����+�*�~�`zDg�=�ch����6�ȏ�W=��/1pD�Ɛ
y��`��*�v<~JJ,�'#��ZK�
��H�am�j���6�ȏ�W=��/M���\�4�:�NC����s��x��5��I����O>��I�ԍ{4��6�ȏ�W=��/���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��6�ȏ�W=��/�y��e�C�AAY<ع��7T����`�7T����`��6�ȏ�W=��/��O���(�:<@����]�a��#��i���O��\?ܖ����5v�ϰ��6�ȏ�W=��/����$|�hH����[UL*�{�o&����ü�_
"B7PZ�	��I�^��6�ȏ�W=��/��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��/���,��җ�7ˑ��	S�续zzN�p�˂hqSЪauth�"�/G���֎�]��/�������s��x��5��I����O>��I�ԍ{4W�,Prd�Y�:�Z1%���H�F��s�#,��җ�7ˑ��	S�续zzN�p�˂hqSЪw��']���z�������H�F��s�#��IL��n����UT%j��Nks�m�b�ģ��Z���6��1��ؗ&�` �m��F��zG��	����S�U������?&�sV{�W��Mx�]{��|ߔ���6��1��ؗ&�` �x���y%1��7-��_>$���f��t���%�X����#E����m�����6��1��ؗ&�` �����s�����F�Q�1G��ׇN���d8Ϡ��6��1��ؗ&�` �����s�����F�Q-x��I��׆���ՠ��6��1��ؗ&�` �����s�����F�QW�,Prd�Y�:�Z1%Ǡ��6��1��ؗ&�` �����s�����F�Qw��']���z�������6��1��ؗ&�` �����s�����F�Q���O�5���
��)]/����6��1��ؗ&�` ��y��e�C�AAY<ع��7T�����7T�������6��1��ؗ&�` ���V�t�8�O_�h��AJx_����3x�j5,�"�/G���֎�]��/���i�U������?&�sV{�W��Mx�]{��|ߔ= Teams: Capability-Based Membership

For multi-agent setups where each agent runs its own pile and
syncs through a relay, capabilities are how the relay decides
who's allowed to read or write. The team CLI lives at
`trible team` (not as a `.rs` faculty — it ships with the
trible CLI itself, since auth setup is pile-specific).

== Quick lifecycle

```sh
# Founder, on machine A:
trible team create --pile shared.pile --key founder.key
# Prints: team root pubkey, team root SECRET (archive offline),
#         founder cap (sig) handle, expiry timestamp.

# Invitee, on machine B:
trible pile net identity --key invitee.key
# Prints: node: <invitee-pubkey>

# Founder issues invitee's cap:
trible team invite --pile shared.pile \
  --team-root <pubkey> --cap <founder-sig> \
  --key founder.key \
  --invitee <invitee-pubkey> --scope read

# Invitee runs the relay, with the issued cap as their credential:
TRIBLE_TEAM_ROOT=<pubkey> TRIBLE_TEAM_CAP=<issued-sig> \
trible pile net sync ./self.pile \
  --peers <founder-node-id> --topic team-graph

# Audit at any time:
trible team list --pile shared.pile
# Lists each cap (issuer → subject, scope, expiry) sorted by
# soonest-to-expire first, plus revocations.
```

== Diagnostics

`trible pile net status --key <key>` prints what auth values
the running peer would present on `OP_AUTH`:

  - `node`: the iroh identity (your peer id)
  - `team_root`: from `TRIBLE_TEAM_ROOT` env var, or single-user
    fallback to your own pubkey
  - `self_cap`: from `TRIBLE_TEAM_CAP` env var, or all-zeros
    sentinel (which the relay rejects — that's the right signal
    that you need to set the env var)

Use this when a connection is being rejected and you want to
double-check what your side is presenting before debugging the
relay.

== When to revoke

  - Lost credentials (laptop with `invitee.key` stolen).
  - Member leaves the team.
  - Compromised cap (e.g. you accidentally pasted
    `TRIBLE_TEAM_CAP` into a public channel).

```sh
trible team revoke --pile shared.pile \
  --team-root-secret <hex> \
  --target <pubkey-of-revoked-member>
```

Revocations cascade transitively: revoking a member's pubkey
also invalidates every cap that member issued downstream.
The relay picks up new revocations on the next snapshot
refresh — no restart.

== When NOT to use this

  - Solo workflows — you're already a team-of-one. The single-user
    fallback (`team_root = signing_key.verifying_key()`) means
    nothing else needs to be set up.
  - Read-only public mirrors — those don't need cap auth, they
    just need anyone-can-read. Currently the protocol assumes
    auth on every connection; "public mode" is its own design.

== Reference

  - User chapter: `triblespace-rs/book/src/capability-auth.md`
  - Library: `triblespace_core::repo::capability` (with
    runnable doctests on every primary public fn)
  - Protocol: `triblespace_net::host::serve_stream`
�"�/G���֎�]��/�����IL��n����UT%j��Nks�m�b�ģ��Zteams�"�/G���֎�]��/����!��t���wY�g �������R�gP�2՛2��h �&f-����p$+(���2|;ƙ9Z�ۭga�\HP�g��0�eu`�M5�՛2��h �&f-��'/�V�3lM.(�h�_&���ԟ#[RM�d���|c�jD�#Ћ�LK~`՛2��h �&f-����H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q՛2��h �&f-�����s�����c\g}��DxM�]g�
�jt�jh՛2��h �&f-����7.4C3�̀�Ӑ�7T����Ѐ7T�����՛2��h �&f-����O���(�:<@���䙯���[]���E���WβaO&\���
�!���A՛2��h �&f-������$|�hH����[UL*�{�o&����ü�_
"B7PZ�	��I�^+ɑ���ң�h�;
�5DxM�]g�
�jt�jh!��t���wY�g �������R�gP�2�"�/G���֎�]��/���/>ɡ�x��u
��\7b@����nok~)u��Local Messages: Agent-to-Agent Direct Messaging�"�/G���֎�]��/����zҍN�My��{���gp�(���� J2?i��_��~��%�v��Ւq��H�F��s�#����SG�����U�);_v'i�ĸ��'�Wb��\�9�a&���;2i�m��F��zG��	����S�4�*��aRQ��k�;�~��&�e���C��x:�\�9�a&���;2i�x���y%1��7-��_>>ɡ�x��u
��\7b@����nok~)u���\�9�a&���;2i����s�����F�Q�1G��ׇN���d8ϑ\�9�a&���;2i����s�����F�Q-x��I��׆���Ց\�9�a&���;2i����s�����F�Q�_��~��%�v��Ւq�\�9�a&���;2i����s�����F�Q���O�5���
��)]/��\�9�a&���;2i����s�����F�Q�KA�N��Y�c0;�*��\�9�a&���;2i�y��e�C�AAY<ع��7T���6��7T���6��\�9�a&���;2i���V�t�8�O_�h���.�s�;,Pz�?�m82�KA�N��Y�c0;�*���H�F��s�#�۬�m�<�7֗��t��@��_�S[#|��B�Q�"�/G���֎�]��/�������SG�����U�);_v'i�ĸ��'�Wb�local-messages�"�/G���֎�]��/���؟\^�4߂fR�Y��{�*�oT�`*Itn���s��uϚ�?�+��_�x��p$+(���2|;�ФC�.+�C	I�輟���I��`)Q/��s��uϚ�?�+��_�x1pD�Ɛ
y��`��*&���ԟ#[RM�d���|c�jD�#Ћ�LK~`�s��uϚ�?�+��_�xM���\�4�:�NC�zҍN�My��{���gp�(���� J2?i��s��uϚ�?�+��_�x���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�s��uϚ�?�+��_�x�y��e�C�AAY<ع��7T���0�7T���0�s��uϚ�?�+��_�x��O���(�:<@�������Ne�U[AYI��(n�Om�BtN�Փj���s��uϚ�?�+��_�x����$|�hH����[��S�Sj4dK���̼�4�H�n�"����1�s��uϚ�?�+��_�x��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��/����4�*��aRQ��k�;�~��&�e���C��x:= Local Messages: Agent-to-Agent Direct Messaging

`local_messages` is the append-only DM primitive. Useful when
you want to leave a note for another agent (or a future-you) that
isn't a wiki fragment — it's transient, addressee-specific, with
read acknowledgements.

== When to use

  - Coordination between two agents on the same pile
    (e.g. "I'm taking over goal X, please don't touch it").
  - Hand-offs that need a read-receipt
    (`local_messages ack <id>`).
  - Notes-to-self that are time-sensitive but not durable enough
    for a wiki fragment.

== When NOT to use

  - Anything reusable across multiple readers — that's a wiki
    fragment. A message decays after the receiver acks it; a
    fragment stays queryable.
  - Long technical content — messages are conversational. If
    you're writing more than 5 lines, ask whether a fragment
    would serve better.
  - Real-time chat — the pile is eventually-consistent across
    relays. Messages land within seconds of a sync, but it's
    not a chat channel.

== Usage

```sh
# Send
local_messages send <recipient-handle> "your message"

# List recent (latest first)
local_messages list

# Mark as read
local_messages ack <message-id>
```

The recipient handle is whatever name maps to a person/agent in
the relations branch (`local_messages --help` shows the
`--relations-branch` flag for picking which branch holds those
mappings — `relations` by default).

== Branch and storage

Messages live on branch `local-messages` in the pile (default —
override via `--branch`). Each message is one append-only blob;
acknowledgements are separate appends, so the read history is its
own audit trail.

The pile-union for this branch is `cat`: when two pile copies
merge, all messages from both sides survive, no overwrites. So
sending the same message twice from different machines just
results in two messages, never lost data.

== Cross-references

  - "How Faculties Work" — the faculty model
  - "Tool Selection: Faculties First" — when to reach for
    local_messages vs wiki vs compass
�"�/G���֎�]��/����۬�m�<�7֗��t��@��_�S[#|��B�Qcoordination�"�/G���֎�]��/������1px����ҭ:�&d_bE�k��|�桕�X�e
*�|��cV&6���p$+(���2|;����QQ]�tLe^��R'�1oV�&��m����e
*�|��cV&6�'/�V�3lM.(�h�_؟\^�4߂fR�Y��{�*�oT�`*Itn��e
*�|��cV&6���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qe
*�|��cV&6����s�����c\g}��DxM�]g�
�jt�jhe
*�|��cV&6���7.4C3�̀�Ӑ�7T������7T�����e
*�|��cV&6���O���(�:<@�����Ro7�@]�?�p��qb���t|*k=�Ȑ+e
*�|��cV&6�����$|�hH����[��S�Sj4dK���̼�4�H�n�"����1+ɑ���ң�h�;
�5DxM�]g�
�jt�jh��1px����ҭ:�&d_bE�k��|�桕�X��"�/G���֎�]��/���L�ɉi����]!��oH��L�h�-\�t�orient�"�/G���֎�]��/���&�E<J�ib��l[0
��Rn���~ �XA3���Orient: The Situation-Snapshot Faculty�"�/G���֎�]��/������1�vB�8�j4�/�|z�G��CP��a�S{�h|UMH-)�c+�G
Bm��F��zG��	����S�I;��,1�z�.?D8ݛ���ŷ�"�+0-��Hh|UMH-)�c+�G
Bx���y%1��7-��_>�E<J�ib��l[0
��Rn���~ �XA3���h|UMH-)�c+�G
B����s�����F�Q�1G��ׇN���d8�h|UMH-)�c+�G
B����s�����F�Q-x��I��׆����h|UMH-)�c+�G
B����s�����F�Q�i���d�S`t��*�7�h|UMH-)�c+�G
B����s�����F�Q���O�5���
��)]/�h|UMH-)�c+�G
B����s�����F�Q�KA�N��Y�c0;�*�h|UMH-)�c+�G
B�y��e�C�AAY<ع��7T���<K�7T���<Kh|UMH-)�c+�G
B��V�t�8�O_�h���+�D�d_�8s����Y@�i���d�S`t��*�7���H�F��s�#L�ɉi����]!��oH��L�h�-\�t��"�/G���֎�]��/����DZ�_�G�H�nn=A����St�=��Ʌ�S�=I0��A	��4���p$+(���2|;�s���r:9|�;���L�N�9%�\�eH�<�S�=I0��A	��4�1pD�Ɛ
y��`��*؟\^�4߂fR�Y��{�*�oT�`*Itn���S�=I0��A	��4�M���\�4�:�NC���1�vB�8�j4�/�|z�G��CP��a�S{��S�=I0��A	��4Ԉ��ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�S�=I0��A	��4ԛy��e�C�AAY<ع��7T���=A �7T���=A �S�=I0��A	��4ԝ�O���(�:<@����\o*��ZEMH֤k�.��U~j`���Rqp�S�=I0��A	��4ԭ���$|�hH����[r��}��)8G���?�/r������o:���S�=I0��A	��4Ե�x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��/����I;��,1�z�.?D8ݛ���ŷ�"�+0-��H= Orient: The Situation-Snapshot Faculty

`orient` answers "what's going on in this pile right now?" in
one command. Run it at the start of a session, after a long break,
or when you're not sure where to pick up.

== What it shows

`orient show` collates three things into one snapshot:

  - Recent local messages (latest first).
  - Compass goals in `doing` (active work).
  - Compass goals in `todo` (queued work).

Defaults to 10 messages + 5 doing + 5 todo; flags
(`--message-limit`, `--doing-limit`, `--todo-limit`) tune the
cutoff.

This is the faculty version of the question "where was I?". It's
a strict cross-faculty read — orient itself doesn't write to the
pile.

== When to use it

  - Session start: before picking up work, see what's actually
    in flight.
  - After a long pause: same idea, larger limits if you've been
    away.
  - Before context-switching: confirm your `doing` is what you
    think it is.
  - As the entry-point of a `/loop` self-paced run: orient is a
    cheap, idempotent read that gives the agent a reason to pick
    one thing over another.

== `orient wait`

`orient wait` blocks until any of the watched branches
changes (compass, local-messages, …) and then prints a fresh
orientation. Useful for:

  - Idle agents waiting for work to land
    (a teammate moves a goal to `doing`, your `wait` returns).
  - Long-running coordination scenarios where you want to react
    to messages without polling.

The wait is pile-snapshot driven, so it sees changes from local
writes AND from gossip-merged remote writes through
`pile net sync`.

== When NOT to use it

  - If you already know what you're doing — orient is for the
    "I lost the thread" case. Mid-task, just keep working.
  - As a status query for one specific thing — `compass list
    doing` or `local_messages list` are sharper if you only
    need one slice.

== Cross-references

  - "Compass Goals Workflow" — the source for the doing/todo
    columns
  - "Local Messages: Agent-to-Agent Direct Messaging" — the
    source for the message column
�"�/G���֎�]��/����{�w������7�������ʾ��aS5�(%81q���Ă��U��p$+(���2|;��m�*�:���}�3T�!B����M��?e�7|e(%81q���Ă��U'/�V�3lM.(�h�_�DZ�_�G�H�nn=A����St�=��Ʌ(%81q���Ă��U��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q(%81q�����U���s�����c\g}��DxM�]g�
�jt�jh(%81q���Ă��U��7.4C3�̀�Ӑ�7T���>��7T���>�(%81q���Ă��U��O���(�:<@����FFh^R�G��v�^,s���0���ݢ+0n(%81q���Ă��U����$|�hH����[r��}��)8G���?�/r������o:��+ɑ���ң�h�;
�5DxM�]g�
�jt�jh{�w������7�������ʾ��aS5��"�/G���֎�]��/����Skk�Z/O���E��>֕G8�����Kߦr��G6�+����#r5����H�F��s�#[��׀�b4�F��ϒߣ�ޯ���ߓA�R��~訍�ˇ�݃��sm�X\��H�F��s�#�m���L�N����&��c�e&!
�
^��*%�O�2�l[!h���f�3-m��F��zG��	����SӲ-�[�zz.zk�!�f~��=���y����O�2�l[!h���f�3-x���y%1��7-��_>��8-�]m�t#@;g��n����PY�%Сe/��O�2�l[!h���f�3-����s�����F�Q�1G��ׇN���d8��O�2�l[!h���f�3-����s�����F�Q-x��I��׆�����O�2�l[!h���f�3-����s�����F�Q6�+����#r5���O�2�l[!h���f�3-����s�����F�Q���O�5���
��)]/��O�2�l[!h���f�3-����s�����F�Q���ˇ�݃��sm�X\�O�2�l[!h���f�3-�y��e�C�AAY<ع��7T���4��7T���4��O�2�l[!h���f�3-��V�t�8�O_�h���sm�s6bƌN��"�/G���֎�]��/���[��׀�b4�F��ϒߣ�ޯ���ߓA�R��~�people�"�/G���֎�]��/���c�;-F�U�z(c׉�˱��b%U��:�|�$n�$r��6�#[R�.8t�.��p$+(���2|;�w��A���S2�w'QG���ݟk
�XD%ɟGe$$r��6�#[R�.8t�.1pD�Ɛ
y��`��*�DZ�_�G�H�nn=A����St�=��Ʌ$r��6�#[R�.8t�.M���\�4�:�NC�Skk�Z/O���E��>֕G8�����Kߦr��G$r��6�#[R�.8t�.���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b$r��6�#[R�.8t�.�y��e�C�AAY<ع��7T���5���7T���5��$r��6�#[R�.8t�.��O���(�:<@���䙔.2��[���r�>n؏.b�As�b�ze�$r��6�#[R�.8t�.����$|�hH����[��F�/grʸ�h�Y��ϲ���l����X��$r��6�#[R�.8t�.��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]��/���%��8-�]m�t#@;g��n����PY�%Сe/�Relations: People and Handle Mappings�"�/G���֎�]��/���:	Ӳ-�[�zz.zk�!�f~��=���y���= Relations: People and Handle Mappings

`relations` is the contact registry. Each entry maps a short
canonical label (the "handle") to a person record with names,
aliases, and free-form notes. Other faculties — most notably
`local_messages` — resolve recipient handles through this
registry.

== Why a separate faculty

The pile branch model means each kind of state lives on its own
branch. Relations stay on `relations`; messages on
`local-messages`; goals on `compass`. Faculties that need
people-references read from `relations` without owning the data.

That separation matters when piles merge: two agents independently
adding a person record for "alice" produce content-addressed
duplicates the lint pass can deduplicate; if relations were
inlined into local-messages each merge would risk inconsistent
addressee data.

== Usage

```sh
# Add a person
relations add jp --first-name "Jan-Paul" --last-name "Bultmann" \
  --display-name "JP" --affinity "user / project lead"

# Add an alias
relations add codex --display-name "Codex subagent" --alias "data-plane"

# List
relations list

# Show one (label, alias, or hex id all work)
relations show jp

# Update
relations set jp --note "Project lead. Prefers async over sync."
```

The label is the short form you'll type at faculty-call sites:
`local_messages send jp "..."` resolves "jp" via the
relations registry.

== Conventions

  - Labels are lowercase, short, alphanumeric. Stable across
    sessions — once chosen, don't rename.
  - Display names are for UI rendering (GORBIE, log lines).
  - Aliases let you address the same entity by multiple
    short forms (`jp`, `bulti`, `liora-jp`).
  - Notes are free-form; affinity is the one-liner ("user",
    "team member", "external collaborator").

== When NOT to use it

  - For ad-hoc "who is this?" lookups during a single session
    — that's the conversation context, not durable state.
  - For network identities (iroh node ids, cap-sig handles) —
    those live in the team CLI's pile state, not in relations.
    Relations is about *people*, not network nodes.

== Cross-references

  - "Local Messages: Agent-to-Agent Direct Messaging" — the
    primary consumer of the relations registry
  - "Compass Goals Workflow" — goals can be assigned to a
    relations label (some compass workflows use this for
    multi-agent kanban)
�"�/G���֎�]��/���	�m���L�N����&��c�e&!
�
^��*%relations�"�/G���֎�]��/����KwU����0@3&�����(@g6���˼��� �����7to̢��p$+(���2|;ƷP����['�8=e��\(��NJ�� �����7to̢'/�V�3lM.(�h�_c�;-F�U�z(c׉�˱��b%U��:�|�$n�� �����7to̢��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q� �����7to̢���s�����c\g}��DxM�]g�
�jt�jh� �����7to̢��7.4C3�̀�Ӑ�7T���7gX�7T���7gX� �����7to̢��O���(�:<@���������k\};ZD;O2��T]Bec����Q��� �����7to̢����$|�hH����[��F�/grʸ�h�Y��ϲ���l����X��+ɑ���ң�h�;
�5DxM�]g�
�jt�jhKwU����0@3&�����(@g6���˼���"�/G���֎�]�0����`�D�!�$��VE8 Y�D�ƄG�������2U6��h�O���0���H�F��s�#�|�b�.�[;oJ���Ղ�/��B�HX:�'I���FB,�F2�Em���H�F��s�#U[�#��S���
e���;��r��ND�c��������?���6��m��F��zG��	����SX�Ɯ"�"�����H��������?�M�������?���6��x���y%1��7-��_>+�L���y�,	9P���A��|S�N�+���������?���6�����s�����F�Q�1G��ׇN���d8��������?���6�����s�����F�Q-x��I��׆�����������?���6�����s�����F�Q2U6��h�O���0��������?���6�����s�����F�QI���FB,�F2�Em��������?���6�����s�����F�Q���O�5���
��)]/��������?���6��y��e�C�AAY<ع��7T���?�X�7T���?�X�������?���6����V�t�8�O_�h��pF��Zx�adi���"�/G���֎�]�0���U[�#��S���
e���;��r��ND�c�web�"�/G���֎�]�0���++�L���y�,	9P���A��|S�N�+��Web: Search and Fetch Through Provider APIs�"�/G���֎�]�0����X�Ɯ"�"�����H��������?�M= Web: Search and Fetch Through Provider APIs

`web` is the agent's web access faculty. Backed by Tavily or
Exa (provider configured via API key). Two operations: `search`
to query the web, `fetch` to pull and clean a single URL.

== Why this exists

  - Direct `curl` from the agent loses provenance — the bytes
    arrive but no record of where they came from. `web`
    persists each request as a pile event with the URL, query,
    timestamp, and response.
  - Provider APIs (Tavily / Exa) extract clean
    text/markdown from cluttered HTML, which beats raw scraping
    for downstream processing.
  - The pile branch becomes a queryable history: "have I
    already pulled this URL? what did it say?" answered without
    re-fetching.

== Usage

```sh
# Provider key in env (Tavily example)
export TAVILY_API_KEY=tvly-...

# Search
web search "succinct hash array mapped trie"

# Fetch a URL (clean markdown when the provider supports it)
web fetch https://arxiv.org/abs/2305.12345
```

`fetch` returns clean text. If you want the original bytes
(PDFs, datasets), use `files fetch <url>` instead — that
archives the raw response under a content hash.

== Coordination with files

A common pattern:

  + `web search "<query>"` — find candidate URLs.
  + Pick a result.
  + `files fetch <url>` — archive the raw bytes
    (`files:<hash>` returned).
  + `wiki create "..." --tag paper` — write a fragment
    citing the `files:<hash>`.

So web is the discovery / clean-extract step; files is
the durable-archive step. Use the right one for each job.

== When NOT to use it

  - Pages that need authentication or interactive
    JavaScript — provider APIs handle static content well, but
    SPA-heavy pages may return shells.
  - Bulk crawling — the provider cost adds up; `wget`/`curl` +
    files is cheaper at volume.
  - Anything you've already pulled this session — check the
    pile's web events branch first.

== Branch and storage

Each `search` and `fetch` records an event on the pile's web
branch (configurable via `--branch-id`). Events accrete; nothing
is overwritten. Querying "what did I fetch about X" is a wiki-
or pattern-style query against the branch.
�"�/G���֎�]�0����|�b�.�[;oJ���Ղ�/��B�HX:�'research�"�/G���֎�]�0����-h������;<�^���ãf�."�^Ms���/����i&^��Oy�5��p$+(���2|;�뫿ik�'�	�U��
��B0q,uţ���tk�/����i&^��Oy�51pD�Ɛ
y��`��*c�;-F�U�z(c׉�˱��b%U��:�|�$n�/����i&^��Oy�5M���\�4�:�NC�`�D�!�$��VE8 Y�D�ƄG�������/����i&^��Oy�5���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b/����i&^��Oy�5�y��e�C�AAY<ع��7T���@Ӹ�7T���@Ӹ/����i&^��Oy�5��O���(�:<@���䙍�:�C�y2b��G#���k�����9�n8R� /����i&^��Oy�5����$|�hH����[@ ��5�#��X����{�`��Ba���t|s�/����i&^��Oy�5��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�0����	7Zw�y�?A�Ma�DtIR�9��T:[�z�v�嗻D��|��,��p$+(���2|;�����c��k�V��
��CiL�`��l;7>v�嗻D��|��,'/�V�3lM.(�h�_�-h������;<�^���ãf�."�^Ms���v�嗻D��|��,��H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qv�嗻D��|��,���s�����c\g}��DxM�]g�
�jt�jhv�嗻D��|��,��7.4C3�̀�Ӑ�7T���Bm��7T���Bm�v�嗻D��|��,��O���(�:<@���䙒;z4_�fj�C(�lZ*���k�+�����X�v�嗻D��|��,����$|�hH����[@ ��5�#��X����{�`��Ba���t|s�+ɑ���ң�h�;
�5DxM�]g�
�jt�jh	7Zw�y�?A�Ma�DtIR�9��T:[�z��"�/G���֎�]�+0���
'���G�K@��p[���&f�^5^�$~�a�7= Recipe: Research Workflow

A worked recipe for the most common agent task: pursue a question,
archive the source material, write up the finding. Chains four
faculties — compass, web, files, wiki — into one durable trail.

== Why a recipe

Per-faculty docs answer "what does X do." Recipes answer "what do
I run, in order, when I want to *accomplish concrete goal*." The
faculty model is composable but the composition isn't obvious
from the individual `--help` outputs.

== The recipe

```sh
# 1. Frame the question as a compass goal.
#    The goal is your container — every artefact below cites it.
GOAL=$(compass add "Investigate <topic>" \
  --tag research \
  --note "Hypothesis: ..." \
  | grep -oE '[0-9a-f]{32}')
compass move "$GOAL" doing

# 2. Search.
web search "<query>"

# 3. For each promising result, archive the raw bytes.
#    Multiple `files fetch` calls are fine — content-
#    addressing dedupes if you accidentally fetch the same URL
#    twice.
files fetch https://arxiv.org/pdf/<id>.pdf
# → files:<hash>   (use this hash below)

# 4. Take notes as fragments while you read.
#    Cite the archived file by hash.
wiki create "<finding title>" "@-" \
  --tag research --tag <topic> <<EOF
= <finding title>

Per files:<hash> (Smith 2024 §3.2), <claim>. The proof
relies on <observation>; key assumption is <X>.

Open: does the bound tighten when <Y>?
EOF

# 5. Cross-link new fragments back to the goal.
compass note "$GOAL" "Wrote up finding: see wiki:<frag-id>"

# 6. When done: outcome note + status done.
compass note "$GOAL" "Conclusion: ..."
compass move "$GOAL" done
```

== Why each step

  - *Compass goal first*: the goal id is a stable handle for
    every cross-reference. If you skip this and just open a
    fragment, you have to retroactively link findings back later.
  - *web search before files fetch*: web gives
    cleaned text + provider-quality results;
    files grabs raw bytes for durable citation.
  - *Fragment per finding, not per session*: atomic fragments
    cross-link cleanly and survive session boundaries. A
    "session log" fragment that tries to capture everything is
    a leaky abstraction.
  - *Outcome note before status done*: the outcome line is
    what future-you (or another agent) will see when scanning
    `compass list done`. Make it useful — what did you
    learn, what's still open.

== Skipping steps

  - For fast lookup ("just need the dates", "what's the URL of
    the paper I read last week"), skip compass. Run
    `wiki search` or `files search` directly.
  - For one-off facts you'll never cite again, skip
    files and just paste the relevant text into a wiki
    fragment with the URL inline. Use judgement: if you'll cite
    the source from another fragment, archive it.

== Variant: hybrid with codex

For literature trawls (read 30 papers, summarise each), launch
codex on step 4 and integrate its output as one fragment per
paper. See "When to Use Codex (and When Not To)" for the launch
pattern. The compass goal still owns the trawl; codex is the
data-plane that fills in the per-paper fragments.

== Cross-references

  - "Web: Search and Fetch Through Provider APIs"
  - "Files Faculty: Archiving and Citing Artefacts"
  - "Wiki Fragment Style Guide"
  - "Compass Goals Workflow"
  - "When to Use Codex (and When Not To)"
�"�/G���֎�]�+0���,�e`����Ko'g��M��tǴÞ��?�<��
�recipe�"�/G���֎�]�+0���<����x�{�A��l��k���z>��utC,�Recipe: Research Workflow�"�/G���֎�]�+0����p�-�+��y������lO����~"8B�cr���y�ѩ�蛌�*�3dm��F��zG��	����S'���G�K@��p[���&f�^5^�$~�a�7y�ѩ�蛌�*�3dx���y%1��7-��_><����x�{�A��l��k���z>��utC,�y�ѩ�蛌�*�3d����s�����F�Q�1G��ׇN���d8�y�ѩ�蛌�*�3d����s�����F�Q-x��I��׆����y�ѩ�蛌�*�3d����s�����F�Q2U6��h�O���0�y�ѩ�蛌�*�3d����s�����F�QA:����Z�N�2,Eޚ�y�ѩ�蛌�*�3d����s�����F�Q���O�5���
��)]/�y�ѩ�蛌�*�3d�y��e�C�AAY<ع��7T���k(�7T���k(y�ѩ�蛌�*�3d��V�t�8�O_�h��f�~�}}�N@!�
��A:����Z�N�2,Eޚ���H�F��s�#,�e`����Ko'g��M��tǴÞ��?�<��
��"�/G���֎�]�+0����|]2D�nx�6�gs�@lʼn����E��ǮB�.��m���5f��Kj��p$+(���2|;�O8�\��t�«��.��U@�I!d?�`�mZ�.��m���5f��Kj1pD�Ɛ
y��`��*�-h������;<�^���ãf�."�^Ms����.��m���5f��KjM���\�4�:�NC�p�-�+��y������lO����~"8B�cr����.��m���5f��Kj���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�.��m���5f��Kj�y��e�C�AAY<ع��7T���lX�7T���lX�.��m���5f��Kj��O���(�:<@���䙫�N��WT^T�"br��m_[j�@�k�K��.��m���5f��Kj����$|�hH����[l�=د�r׺�
G�����6�;�T"��k��.��m���5f��Kj��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�+0����l�w,#��X��bzw� U(��ZTX:70<��҉�/U�4�k��I��,���p$+(���2|;�u����2���mD��X`4�R���b��%Lt,�/U�4�k��I��,�'/�V�3lM.(�h�_�|]2D�nx�6�gs�@lʼn����E��ǮB�/U�4�k��I��,���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q�/U�4�k��I��,Ȇ��s�����c\g}��DxM�]g�
�jt�jh�/U�4�k��I��,ȓ�7.4C3�̀�Ӑ�7T���m�؀7T���m���/U�4�k��I��,ȝ�O���(�:<@����?%Z����nۇ%Jh����A��x�6{n1�~�/U�4�k��I��,ȭ���$|�hH����[l�=د�r׺�
G�����6�;�T"��k�+ɑ���ң�h�;
�5DxM�]g�
�jt�jhl�w,#��X��bzw� U(��ZTX:70<��҉�"�/G���֎�]�P0���@-Ë��(�yڥ"4�h�~�]�&:��6�ȓ^ZskIɶ������m��F��zG��	����SGB�I����=o_<��ט��\�	�e�x^ZskIɶ������x���y%1��7-��_>���nu��c4WJ!�<)ݾ
fh�+�k���_0^ZskIɶ�����ܑ���s�����F�Q�1G��ׇN���d8�^ZskIɶ�����ܑ���s�����F�Q-x��I��׆����^ZskIɶ�����ܑ���s�����F�QA:����Z�N�2,Eޚ�^ZskIɶ�����ܑ���s�����F�Q���O�5���
��)]/�^ZskIɶ�����ܑ���s�����F�Q�KA�N��Y�c0;�*�^ZskIɶ�����ܛy��e�C�AAY<ع��7T��ϭ�Ѐ7T��ϭ��^ZskIɶ��������V�t�8�O_�h����>�w(��&�Ws
|/�"�/G���֎�]�P0���.GB�I����=o_<��ט��\�	�e�x= Recipe: Multi-Agent Coordination

How two agents working on the same pile (or on team-mesh-synced
piles) hand work back and forth without stepping on each other.
Chains `relations`, `local_messages`, `orient`, and `compass`.

== Why a recipe

Each faculty in isolation is obvious. The non-obvious thing is
the *handshake order* — which faculty signals which event so the
other agent picks it up. Skip steps and you get racy work
(both agents claiming the same goal) or silent drops (a message
that was sent but never read).

== The recipe — Agent A hands work to Agent B

```sh
# Setup (once, on each pile):
relations add jp --display-name "JP" --affinity "user"
relations add agent-b --display-name "Agent B" --affinity "teammate"

# Agent A: claim the goal first.
GOAL=<existing-goal-id>
compass move $GOAL doing
compass note $GOAL "Claimed by agent-a, draft pending"

# Agent A: do partial work, then prepare hand-off.
compass note $GOAL "Draft at wiki:<frag-id>; need agent-b to verify the calculation"
compass move $GOAL blocked   # signals "external dependency"
local_messages send agent-b "Goal $GOAL ready for review — see wiki:<frag-id>"

# Agent B (later, possibly different session):
orient show                  # surfaces the new message + blocked goal
local_messages ack <msg-id>  # read receipt
compass move $GOAL doing
compass note $GOAL "Picked up by agent-b for review"

# Agent B does the work, hands back:
compass note $GOAL "Verified §3.2; numbers correct. Pushed back to A."
local_messages send agent-a "Done with review on $GOAL"
compass move $GOAL doing     # NOT done — A still owns the goal
```

== Why each step

  - *relations once per pile*: handles resolve through this
    registry. Without it, `local_messages send agent-b ...`
    can't address the recipient.
  - *Status change before sending the message*: `compass move $GOAL blocked` first.
    the status change is the durable signal; the message is
    the polite notification. If the message is missed, the next
    `orient show` from B still surfaces the blocked goal.
  - *Notes on every transition*: the goal's history is the
    audit trail. "Claimed by", "Draft at", "Verified", "Pushed
    back" — each note records what happened and who did it.
  - *Don't move to done across the handshake*: only the agent
    who *originated* the goal should mark it done. B verifies
    and hands back; A confirms and closes.

== orient wait for idle agents

If Agent B is running a `/loop` or sitting idle, replace
`orient show` with `orient wait` — that blocks until any
relevant branch changes, including gossip-merged remote writes
through `pile net sync`.

```sh
# Agent B's idle loop:
while true; do
  orient wait    # blocks until something arrives
  # ...handle whatever showed up...
done
```

== Conflict resolution

Pile branches are append-only with `cat` union for compass and
local-messages, so concurrent writes never overwrite. Two agents
both moving the same goal to `doing` produces two status events
in chronological order; `compass list` shows the latest.

For genuine ambiguity ("we both started working on this"), the
fix is a quick `local_messages send <other> "I'm taking this
one — you grab X"` — a coordination layer the system supports
but doesn't enforce.

== Cross-references

  - "Local Messages: Agent-to-Agent Direct Messaging"
  - "Relations: People and Handle Mappings"
  - "Orient: The Situation-Snapshot Faculty"
  - "Compass Goals Workflow"
  - "Teams: Capability-Based Membership" — for inter-pile sync
    over a real network (gossip + DHT), the auth-arc tools
    underneath this recipe.
�"�/G���֎�]�P0��� ���nu��c4WJ!�<)ݾ
fh�+�k���_0Recipe: Multi-Agent Coordination�"�/G���֎�]�P0����s��K�!�A4�Oq��Ehs�^v^��k���V�'a�2�0����c�:^��>��p$+(���2|;�	4[�5f�1[?1#/_8�y�;V��YIex�-�a�2�0����c�:^��>1pD�Ɛ
y��`��*�|]2D�nx�6�gs�@lʼn����E��ǮBa�2�0����c�:^��>M���\�4�:�NC�-Ë��(�yڥ"4�h�~�]�&:��6�ȓa�2�0����c�:^��>���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2ba�2�0����c�:^��>�y��e�C�AAY<ع��7T��Ϯ~x�7T��Ϯ~xa�2�0����c�:^��>��O���(�:<@���䙻]eϞ�iO����ϖ���,l����/ۗa�2�0����c�:^��>����$|�hH����[�K�����8�=�]�j��`��\��ԉ<o;a�2�0����c�:^��>��x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�Q0�������a�0k��1�k7�DMj��"�#Q��ր�i�o9{,����3<]���p$+(���2|;�b��q�b)>u������zJ�:(�:{�{dXi�o9{,����3<]�'/�V�3lM.(�h�_�s��K�!�A4�Oq��Ehs�^v^��k���V�'i�o9{,����3<]���H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������qi�o9{,����3<]����s�����c\g}��DxM�]g�
�jt�jhi�o9{,����3<]���7.4C3�̀�Ӑ�7T��ϰ3��7T��ϰ3�i�o9{,����3<]���O���(�:<@����WWS�餈��<�F�-g����^&6�ջ�b���i�o9{,����3<]�����$|�hH����[�K�����8�=�]�j��`��\��ԉ<o;+ɑ���ң�h�;
�5DxM�]g�
�jt�jh���a�0k��1�k7�DMj��"�#Q��ր��"�/G���֎�]�v0���)ߧ�3�ڬ��܆~�v�i���X9~ġ��ɛRecipe: Auth Setup for a Multi-Agent Team�"�/G���֎�]�v0���I���C���`D�U?�h���Ñ�4����^�D.ǣ�LӌV\�����p$+(���2|;�rMW��m�����K�?��oY�Y�\�Q�~��b�D.ǣ�LӌV\���1pD�Ɛ
y��`��*�s��K�!�A4�Oq��Ehs�^v^��k���V�'D.ǣ�LӌV\���M���\�4�:�NC�t���L��6:��,�@ͮe�7�YQ�#_b�D.ǣ�LӌV\������ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2bD.ǣ�LӌV\����y��e�C�AAY<ع��7T����I`�7T����I`D.ǣ�LӌV\�����O���(�:<@����C�x���J��VQ�~�������5��`PnڂbD.ǣ�LӌV\�������$|�hH����[���]h�YdD�ĺ����!����fA�âT�|D.ǣ�LӌV\�����x9nԱe�v���,�NO��I
�j��:��8T5�-1v9����"�/G���֎�]�v0���@t���L��6:��,�@ͮe�7�YQ�#_b��"��Q�T��J��.�m��F��zG��	����S�Wx�>සΨz��,��uy���Y�;�E���"��Q�T��J��.�x���y%1��7-��_>ߧ�3�ڬ��܆~�v�i���X9~ġ��ɛ�"��Q�T��J��.Б���s�����F�Q�1G��ׇN���d8��"��Q�T��J��.Б���s�����F�Q-x��I��׆�����"��Q�T��J��.Б���s�����F�QA:����Z�N�2,Eޚ��"��Q�T��J��.Б���s�����F�QW�,Prd�Y�:�Z1%��"��Q�T��J��.Б���s�����F�Q���O�5���
��)]/��"��Q�T��J��.Лy��e�C�AAY<ع��7T����W0�7T����W0�"��Q�T��J��.���V�t�8�O_�h��2�$b���ݻ:�ø���"�/G���֎�]�v0����Wx�>සΨz��,��uy���Y�;�E��= Recipe: Auth Setup for a Multi-Agent Team

How to bootstrap capability auth so two or more agents can sync a
shared pile through a relay without exposing it to anyone else.
Chains `trible team`, `trible pile net`, and the env-var
configuration the relay reads.

== Why a recipe

Per-faculty docs cover `team create`, `team invite`, etc. in
isolation. This recipe shows the *order of operations* across
two machines (founder + invitee) so the handoff doesn't drop
mid-stream — one missing env var on the relay side and every
connection silently rejects.

== The recipe — founder bootstraps, invites one teammate

```sh
# === Founder, on machine A ===

# 1. Create the team. ARCHIVE the SECRET line offline before
#    moving past this prompt.
trible team create --pile shared.pile --key founder.key
# → team root pubkey:  d5263a4d...
# → team root SECRET:  <archive offline; never commit>
# → founder cap (sig): 4e6e02d5...
# → expires: 2026-05-28 ...

# 2. Tell the invitee to print their iroh identity:
#      ssh invitee@machine-b "trible pile net identity --key node.key"
# → node: c726b586...

# 3. Issue the invitee's cap.
trible team invite \
  --pile shared.pile \
  --team-root d5263a4d... \
  --cap 4e6e02d5... \
  --key founder.key \
  --invitee c726b586... \
  --scope read
# → issued cap (sig): f0f6f41e...

# 4. Send the (team_root, issued_cap_sig) pair to the invitee.
#    These two values are NOT secrets — the team_root is the
#    public verification anchor, the cap-sig handle is a
#    content-addressed reference. Safe to email/Signal/etc.

# === Invitee, on machine B ===

# 5. Set the env vars and verify what they'll present:
export TRIBLE_TEAM_ROOT=d5263a4d...
export TRIBLE_TEAM_CAP=f0f6f41e...
trible pile net status --key node.key
# → node:      c726b586...
# → team_root: d5263a4d...  (from TRIBLE_TEAM_ROOT)
# → self_cap:  f0f6f41e...  (from TRIBLE_TEAM_CAP)

# 6. Optional: rehearse the auth handshake locally before
#    connecting. Requires the founder to have shared the
#    cap blob too (typically via the same gossip mesh, but for
#    first connection you can copy `shared.pile` over).
trible team show --pile shared.pile --cap "$TRIBLE_TEAM_CAP" \
  --verify "$TRIBLE_TEAM_ROOT"
# → ✓ VERIFIED  ←  matches what the relay would report at OP_AUTH

# 7. Connect to the relay (founder) and sync.
trible pile net sync ./local.pile \
  --peers <founder-iroh-node-id> \
  --topic our-team-graph \
  --key node.key
```

== Why each step

  - *team create first, before anything else*: the team root
    SECRET is generated here and you can't recover it. Archive
    BEFORE proceeding.
  - *Identity exchange via plain text*: pubkeys and cap handles
    are not secrets. Don't paranoid-encrypt them; do paranoid-
    encrypt the team root SECRET.
  - *pile net status before sync*: the diagnostic confirms
    what would be presented on `OP_AUTH`. Catches "I forgot to
    `export`" before it produces "connection refused" with no
    further info.
  - *team show --verify as rehearsal*: the relay enforces auth
    at `OP_AUTH` time. `team show --verify` runs the same
    `verify_chain` locally so you see the result without
    needing to debug a network round-trip.
  - *--topic on sync*: the gossip mesh is per-topic. The
    invitee and founder must use the SAME topic name or they're
    on different meshes and won't see each other's HEAD
    announcements.

== Revoking a teammate

```sh
# Founder needs the team root SECRET (loaded from the offline
# archive, NOT from $TRIBLE_TEAM_CAP — that's the founder's
# operating cap, not the team root's secret key).
trible team revoke \
  --pile shared.pile \
  --team-root-secret <secret-hex-from-offline-archive> \
  --target <revoked-pubkey-hex>

# The revocation cascades transitively: every cap the revoked
# pubkey signed (or chained through) is invalidated. The next
# `pile net sync` snapshot refresh on each relay picks it up
# without restart.
```

== Cross-references

  - "Teams: Capability-Based Membership" — per-command
    detail and the env-var fallback semantics
  - "Recipe: Multi-Agent Coordination" — how agents
    coordinate AFTER they're synced (this recipe gets them
    synced; that one runs them through their first hand-off)
  - The `triblespace-rs/book/src/capability-auth.md` chapter
    has the complete protocol-level reference
�"�/G���֎�]�v0�����%��sќw(;d���(s�
gG���A�d���֋En~�������p$+(���2|;�>~ŻƧ��`#�`@1^��Q�2A���_i����֋En~�����'/�V�3lM.(�h�_I���C���`D�U?�h���Ñ�4����^����֋En~�������H�F��s�#�Ւ1�j�i�
Sbz2N5"f}C=Yr6������q���֋En~��������s�����c\g}��DxM�]g�
�jt�jh���֋En~�������7.4C3�̀�Ӑ�7T���� �7T���� ���֋En~�������O���(�:<@���䙖��	=w�Gא�j��Ȑ��%�_�žBO���֋En~���������$|�hH����[���]h�YdD�ĺ����!����fA�âT�|+ɑ���ң�h�;
�5DxM�]g�
�jt�jh�%��sќw(;d���(s�
gG���A�d�"�/G���֎�]��1����P��;�!���`,ԼV�1����
c���xЕ�32���+��U�r�v���H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$�32���+��U�r�v����s�����c\g}��CB�(�kQ�Np�32���+��U�r�v���7.4C3�̀�Ӑ�7T�����0�7T�����0+ɑ���ң�h�;
�5CB�(�kQ�Np�P��;�!���`,ԼV�1����
c���xЕ��"�/G���֎�]��1���e�'�v�4k=!} ���"/Ov�5��o��U:add goal�"�/G���֎�]��1����*u&d���<�jH(�%ـפ��Wwx��B4�i�"�m��fan�
�p��H�F��s�#�t_�,XLr��e���Q�.� (:$�ձ��GeABF@*j��o�;��H�F��s�#~�nF������]��#�
��x��Q���:ʫ��b8�0�c�z;�~���H�F��s�#��������Ӊ}VjGN���x7}
]��T�&6�`+2wI_N!MJA|��`��H�F��s�#�g�U��Ü{�@ ��Y�?�Ā#A�Sc��o�Nf� v�Lq_��H�F��s�#-�!Y`���ྕ�^;.�]ϯ�p
��bv�����1�hF�:o@G5�=ږ�0QW�Sׁ�Uo�8�^o~ʪe��D )x�\��`�;�l��1�hF�:o@����s�����F�Q��o�Nf� v�Lq_��1�hF�:o@�y��e�C�AAY<ع��7T���9;�7T���9;��1�hF�:o@������L�}B�,��1��O�c����ai���1��O�c����ai�_���?l5��W!oi�bootstrap��1��O�c����ai�_���?l5��W!oi�onboarding��1��O�c����ai�����s�����F�Q�GeABF@*j��o�;��1��O�c����ai��y��e�C�AAY<ع��7T���9;�7T���9;��1��O�c����ai����\C�/�g.F��
e�����"X��d��9�U�KE�U��1���g�J͛P&a�N�sD>Ւ���todo��1���g�J͛P&����s�����F�Q�`+2wI_N!MJA|��`��1���g�J͛P&�y��e�C�AAY<ع��7T���9;�7T���9;��1���g�J͛P&������L�}B�,��1��O�c����ai��"�/G���֎�]��1���!�
e�����"X��d��9�U�KE�URead the start-here wiki fragment�"�/G���֎�]��1�����Uo�8�^o~ʪe��D )x�\��`�;�lRun `wiki.rs list --tag bootstrap` to find the 'Getting Started: Your First Hour' fragment, then `wiki.rs show <id>` to read it. This is your orientation tour.�"�/G���֎�]��1����ҥ�c�v�X�����ۄ_�S�~i�r�������I�~jK��Di���p$+(���2|;�в�k��n3���(8tW����)1�i]&^���I�~jK��Di�M���\�4�:�NC�*u&d���<�jH(�%ـפ��Wwx��B4ӄ�I�~jK��Di����ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��I�~jK��Di��y��e�C�AAY<ع��7T���9�x�7T���9�x��I�~jK��Di���O���(�:<@����}6]؋��_�݀�U�wh^f�\�Z���#�t�Є�I�~jK��Di�����$|�hH����[��r��ce|�K�9�6V��T�77�����I�~jK��Di���x9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]��1����2f��H�¬����}��xo?&�/F�g=����� }$����y��g�E��p$+(���2|;Ʋq�d�f�����1�VE�?�j���c���_�� }$����y��g�E'/�V�3lM.(�h�_ҥ�c�v�X�����ۄ_�S�~i�r������� }$����y��g�E��H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$� }$����y��g�E���s�����c\g}��CB�(�kQ�Np೉ }$����y��g�E��7.4C3�̀�Ӑ�7T���;qx�7T���;qx�� }$����y��g�E��O���(�:<@����
��l"�9�)L>����4j��.G.z�Dڴ�� }$����y��g�E����$|�hH����[��r��ce|�K�9�6V��T�77���+ɑ���ң�h�;
�5CB�(�kQ�Np�2f��H�¬����}��xo?&�/F�g=����"�/G���֎�]��1���&	�H�7�ʿ���V`<���gC��z�#TGR$�;Mint your first id with `trible genid`�"�/G���֎�]��1����b|���c
�	fP�zy��)8�$�M*G�Stable IDs in TribleSpace are minted, never guessed. Run `trible genid` and copy the 32-char hex output. Try minting 3 in a row — they should all be different.�"�/G���֎�]��1���@vK�,�.�,�y�}7aH�EQ6q�5�Z���&�L���1�G �k�3�׹5_���?l5��W!oi�bootstrap��1�G �k�3�׹5_���?l5��W!oi�faculties��1�G �k�3�׹5����s�����F�Q�GeABF@*j��o�;��1�G �k�3�׹5�y��e�C�AAY<ع��7T���#��7T���#���1�G �k�3�׹5���\C�/�g.F�	�H�7�ʿ���V`<���gC��z�#TGR$�;��1�lufM{ʮ�J�6G5�=ږ�0QW�Sׁb|���c
�	fP�zy��)8�$�M*G���1�lufM{ʮ�J�6����s�����F�Q��o�Nf� v�Lq_��1�lufM{ʮ�J�6�y��e�C�AAY<ع��7T���#��7T���#���1�lufM{ʮ�J�6������L�}B�,��1�G �k�3�׹5��1�� ��Y	_,�?�a�N�sD>Ւ���todo��1�� ��Y	_,�?����s�����F�Q�`+2wI_N!MJA|��`��1�� ��Y	_,�?�y��e�C�AAY<ع��7T���#��7T���#���1�� ��Y	_,�?�������L�}B�,��1�G �k�3�׹5�"�/G���֎�]��1����Շ�P�kܾ��W�߁}y�j���]�������]�����rJ"M�K���p$+(���2|;���cKa89o��S�St(ϝW1A��H���F���]�����rJ"M�K�1pD�Ɛ
y��`��*ҥ�c�v�X�����ۄ_�S�~i�r�������]�����rJ"M�K�M���\�4�:�NC�vK�,�.�,�y�}7aH�EQ6q�5�Z���&�L���]�����rJ"M�K����ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b��]�����rJ"M�K��y��e�C�AAY<ع��7T���%X�7T���%X��]�����rJ"M�K���O���(�:<@����W���3��@���^1qz��e��髭f��]�����rJ"M�K�����$|�hH����[]����.�x��4���z��'y�&늭��]�����rJ"M�K���x9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]��1�����b�ud����կ!�S��i��2�h�u��e%E������U.p����p$+(���2|;ƽr��PB��|��%<`��O�K��)G��
e%E������U.p��'/�V�3lM.(�h�_�Շ�P�kܾ��W�߁}y�j���]�����e%E������U.p����H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$�e%E������U.p�ˆ��s�����c\g}��CB�(�kQ�Np�e%E������U.p�˓�7.4C3�̀�Ӑ�7T���&b�7T���&be%E������U.p�˝�O���(�:<@���䙣�V�D",_�6#��[�/�7���`[JB�Fq���e%E������U.p�˭���$|�hH����[]����.�x��4���z��'y�&늭+ɑ���ң�h�;
�5CB�(�kQ�Np��b�ud����կ!�S��i��2�h�u���"�/G���֎�]��1���.
,3z)9�an�rP�\ `6S�at�"r�Y�|;�W�K.z(Ϟ�n2��p$+(���2|;��4�nڋ�ο�i�i�:"o"\�u������W�K.z(Ϟ�n21pD�Ɛ
y��`��*�Շ�P�kܾ��W�߁}y�j���]������W�K.z(Ϟ�n2M���\�4�:�NC���s���+0d`���<)�k_��1B'�XdB
�N��W�K.z(Ϟ�n2���ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�W�K.z(Ϟ�n2�y��e�C�AAY<ع��7T����+Ȁ7T����+��W�K.z(Ϟ�n2��O���(�:<@����#t�JF�����-�3�����YXN�
��yM	Q�W�K.z(Ϟ�n2����$|�hH����[�"��ц��@�����+�"�����'�'���W�K.z(Ϟ�n2��x9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]��1����G5������A�C~�}�G��_ܳ�P
�3״Pick something you've learned today. Write a 5-10 line typst body to /tmp/myfrag.typ, then `wiki.rs create "My first fragment" @/tmp/myfrag.typ --tag personal`. Verify with `wiki.rs show <id>`.�"�/G���֎�]��1���p�8�am�9�P�q����lί�k�'��ilCreate your first wiki fragment�"�/G���֎�]��1���@��s���+0d`���<)�k_��1B'�XdB
�N���1�(�P�{����_���?l5��W!oi�bootstrap��1�(�P�{����_���?l5��W!oi�wiki��1�(�P�{��������s�����F�Q�GeABF@*j��o�;��1�(�P�{�����y��e�C�AAY<ع��7T������7T�������1�(�P�{�������\C�/�g.F�p�8�am�9�P�q����lί�k�'��il��1�b6�r3<)�_a�N�sD>Ւ���todo��1�b6�r3<)�_����s�����F�Q�`+2wI_N!MJA|��`��1�b6�r3<)�_�y��e�C�AAY<ع��7T������7T�������1�b6�r3<)�_������L�}B�,��1�(�P�{������1�\֪��n����G5�=ږ�0QW�SׁG5������A�C~�}�G��_ܳ�P
�3״��1�\֪��n��������s�����F�Q��o�Nf� v�Lq_��1�\֪��n�����y��e�C�AAY<ع��7T������7T�������1�\֪��n����������L�}B�,��1�(�P�{�����"�/G���֎�]��1����2�-�c��\������k�Z_���~?-s!�|����!"�IŢ�5]B���p$+(���2|;�{��M���h(�=���J���q��t��p�*����!"�IŢ�5]B�'/�V�3lM.(�h�_.
,3z)9�an�rP�\ `6S�at�"r�Y�|;����!"�IŢ�5]B���H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$����!"�IŢ�5]B����s�����c\g}��CB�(�kQ�Np����!"�IŢ�5]B���7.4C3�̀�Ӑ�7T����p�7T����p����!"�IŢ�5]B���O���(�:<@��������j��2�v[exfh���h�j�=�pL�_����!"�IŢ�5]B�����$|�hH����[�"��ц��@�����+�"�����'�'��+ɑ���ң�h�;
�5CB�(�kQ�Np�2�-�c��\������k�Z_���~?-s!�|��"�/G���֎�]��1���"�U���KxG�p���'�b���G�$S^?&?�Archive a file with `files.rs add`�"�/G���֎�]��1����/�-H!���PἫ�e�*�ғ�aX��$��[�A=Pick any local file (not a binary in a git repo). Run `files.rs add <path>`. The output `files:<hash>` is a content-addressed reference you can cite from wiki fragments. Confirm the hash is stable: re-run on the same file, same hash.�"�/G���֎�]��1���T��\���`�Y�E���*@�$��
K�GL�q�z���W�������p$+(���2|;ƅӼ!��Գ�?��||É�3����33�]�pQ�z���W�����1pD�Ɛ
y��`��*.
,3z)9�an�rP�\ `6S�at�"r�Y�|;�z���W�����M���\�4�:�NC��Sc�̚�*�O��r��/e�G������"�w9�z���W����܈��ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�z���W����ܛy��e�C�AAY<ع��7T�����7T�����z���W����ܝ�O���(�:<@�����9��`�>��x��&��wJ[F���xb ��z���W����ܭ���$|�hH����[8'27��s4��
�miF�;Z��y#����um�z���W����ܵ�x9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]��1���@�Sc�̚�*�O��r��/e�G������"�w9��1�#�]�nr.��e��_���?l5��W!oi�bootstrap��1�#�]�nr.��e��_���?l5��W!oi�files��1�#�]�nr.��e�ޑ���s�����F�Q�GeABF@*j��o�;��1�#�]�nr.��e�ޛy��e�C�AAY<ع��7T����K8�7T����K8��1�#�]�nr.��e�����\C�/�g.F��U���KxG�p���'�b���G�$S^?&?���1�.-�DYL��WG5�=ږ�0QW�Sׁ/�-H!���PἫ�e�*�ғ�aX��$��[�A=��1�.-�DYL��W����s�����F�Q��o�Nf� v�Lq_��1�.-�DYL��W�y��e�C�AAY<ع��7T����K8�7T����K8��1�.-�DYL��W������L�}B�,��1�#�]�nr.��e����1�3lx,ۄ���&a�N�sD>Ւ���todo��1�3lx,ۄ���&����s�����F�Q�`+2wI_N!MJA|��`��1�3lx,ۄ���&�y��e�C�AAY<ع��7T����K8�7T����K8��1�3lx,ۄ���&������L�}B�,��1�#�]�nr.��e���"�/G���֎�]��1��������C�V:\�[��#�7j��!�+g}�e��0M��8���������p$+(���2|;�3��V���Ӷ��n�Q҈�\�Norw���b#M��8�������'/�V�3lM.(�h�_T��\���`�Y�E���*@�$��
K�GL�qM��8���������H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$�M��8����������s�����c\g}��CB�(�kQ�Np�M��8���������7.4C3�̀�Ӑ�7T������7T�����M��8���������O���(�:<@����|$1��*�z�a��y&��mK�
��H�3_H{M��8�����������$|�hH����[8'27��s4��
�miF�;Z��y#����um+ɑ���ң�h�;
�5CB�(�kQ�Np����C�V:\�[��#�7j��!�+g}�e��0�"�/G���֎�]�2���&&���~�E�t����mH/�Ăl����8Run `wiki.rs lint` and `wiki.rs check`�"�/G���֎�]�2����_t|�n�?M���@GjV��`~)Q#'7!Glint applies markdown→typst transforms and rebuilds the links_to index. check reports orphan fragments, broken links, truncated ids. Run both. Note any warnings — they're the wiki's self-diagnostic surface.�"�/G���֎�]�2����p�D��=J�P����HM5s;��kNٖ�݋z���2[�ז�
\���ȚG5�=ږ�0QW�Sׁ_t|�n�?M���@GjV��`~)Q#'7!G��2[�ז�
\���Ț����s�����F�Q��o�Nf� v�Lq_��2[�ז�
\���Ț�y��e�C�AAY<ع��7T���t��7T���t���2[�ז�
\���Ț������L�}B�,��2��^�0�VĤj9��2z�}��1FQ��Pa�N�sD>Ւ���todo��2z�}��1FQ��P����s�����F�Q�`+2wI_N!MJA|��`��2z�}��1FQ��P�y��e�C�AAY<ع��7T���t��7T���t���2z�}��1FQ��P������L�}B�,��2��^�0�VĤj9��2��^�0�VĤj9_���?l5��W!oi�bootstrap��2��^�0�VĤj9_���?l5��W!oi�hygiene��2��^�0�VĤj9_���?l5��W!oi�wiki��2��^�0�VĤj9����s�����F�Q�GeABF@*j��o�;��2��^�0�VĤj9�y��e�C�AAY<ع��7T���t��7T���t���2��^�0�VĤj9���\C�/�g.F�&���~�E�t����mH/�Ăl����8�"�/G���֎�]�2�����|$�^�E�
�3�Y
i��[�
��p���o��z?�Oy:SW9����p$+(���2|;�t�@�ex�I–=z�����:���}䙒��g�o��z?�Oy:SW9��1pD�Ɛ
y��`��*T��\���`�Y�E���*@�$��
K�GL�q�o��z?�Oy:SW9��M���\�4�:�NC�p�D��=J�P����HM5s;��kNٖ�݋z��o��z?�Oy:SW9�∵�ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�o��z?�Oy:SW9��y��e�C�AAY<ع��7T���j`�7T���j`�o��z?�Oy:SW9���O���(�:<@����m�$u-�V�cٍ��mP�o����_���K
�o��z?�Oy:SW9�⭴��$|�hH����[V�+�b_�����5|�-8n=f.<s���o��z?�Oy:SW9�ⵝx9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]�2��������Tt~o�ޭk���Bv��F]?9ċ�s��?���5�����+�c��p$+(���2|;�ը�ޑ��N`�-��<����
�F:[����?���5�����+�c'/�V�3lM.(�h�_��|$�^�E�
�3�Y
i��[�
��p���?���5�����+�c��H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$��?���5�����+�c���s�����c\g}��CB�(�kQ�Np��?���5�����+�c��7.4C3�̀�Ӑ�7T���F��7T���F��?���5�����+�c��O���(�:<@�����k����p<�s;�cA��#��)� �����9X�?���5�����+�c����$|�hH����[V�+�b_�����5|�-8n=f.<s��+ɑ���ң�h�;
�5CB�(�kQ�Np࿝��Tt~o�ޭk���Bv��F]?9ċ�s��"�/G���֎�]�2���@4���C�\�*��"U=>�:����"����r��2nq��]S]ٺAa�N�sD>Ւ���todo��2nq��]S]ٺA����s�����F�Q�`+2wI_N!MJA|��`��2nq��]S]ٺA�y��e�C�AAY<ع��7T���l�H�7T���l�H��2nq��]S]ٺA������L�}B�,��2��uX�r��R�
���2���q�~�����G5�=ږ�0QW�Sׁ���dYv	�H�$?+H��OSN����aZ�@t%2��2���q�~���������s�����F�Q��o�Nf� v�Lq_��2���q�~������y��e�C�AAY<ع��7T���l�H�7T���l�H��2���q�~�����������L�}B�,��2��uX�r��R�
���2��uX�r��R�
�_���?l5��W!oi�bootstrap��2��uX�r��R�
�_���?l5��W!oi�compass��2��uX�r��R�
�����s�����F�Q�GeABF@*j��o�;��2��uX�r��R�
��y��e�C�AAY<ع��7T���l�H�7T���l�H��2��uX�r��R�
����\C�/�g.F��D�3�k�����th�ŕD�Oûe%��U�w���"�/G���֎�]�2�������dYv	�H�$?+H��OSN����aZ�@t%2When you finish working through the bootstrap goals, move this one to done with `compass.rs move <id> done` and add a final note recording what stuck and what you'd improve. The outcome note IS the audit trail.�"�/G���֎�]�2��������F���k����;9H�/m~zr�	�Z��r<�v��d���p$+(���2|;��X�]=�g����h�/]i���U�{�~�+oQt
�	�Z��r<�v��d�1pD�Ɛ
y��`��*��|$�^�E�
�3�Y
i��[�
��p���	�Z��r<�v��d�M���\�4�:�NC�4���C�\�*��"U=>�:����"����r�	�Z��r<�v��d����ԗT
ŮͷQ�s|��I������@M�6��I��%ɭ��̚���2b�	�Z��r<�v��d��y��e�C�AAY<ع��7T���p��7T���p��	�Z��r<�v��d���O���(�:<@�����^��{}g�g4.>E�Q��P=K��c��ޑO�y��	�Z��r<�v��d�����$|�hH����[��ף(�N�j�U�`:)�d�Y<����u]�1mX�	�Z��r<�v��d���x9nԱe�v��e�'�v�4k=!} ���"/Ov�5��o��U:�"�/G���֎�]�2���-�D�3�k�����th�ŕD�Oûe%��U�w��Mark this goal done and write an outcome note�"�/G���֎�]�2����ʌ�"ݯ^����/&�L�&p�b�2����Ȏ��� �|�=K�~��p$+(���2|;Ƣ�fz-�<��y�����������z
 =��`
Ȏ��� �|�=K�~'/�V�3lM.(�h�_�����F���k����;9H�/m~zrȎ��� �|�=K�~��H�F��s�#O1}X�A�{�K&]�rh%�`��c�x�[$�Ȏ��� �|�=K�~���s�����c\g}��CB�(�kQ�Np�Ȏ��� �|�=K�~��7.4C3�̀�Ӑ�7T���q�p�7T���q�pȎ��� �|�=K�~��O���(�:<@�����y��UAelp�o�8U�`X�w��K[�Ȏ��� �|�=K�~����$|�hH����[��ף(�N�j�U�`:)�d�Y<����u]�1mX+ɑ���ң�h�;
�5CB�(�kQ�Np�ʌ�"ݯ^����/&�L�&p�b�2����