Cosa calcola Pathrule

Scrivi tre tipi di cose: memorie, regole e skill. Quella parte è intenzionale, curata, ed è tua.

È però la metà più piccola. Gran parte di ciò che il livello contiene in un dato momento non è stata digitata da nessuno. Deriva da come procede davvero il lavoro, viene conservata per workspace e ricalcolata man mano che il lavoro va avanti. Questa pagina descrive ogni parte derivata, perché sapere cosa c'è spiega perché il recupero si comporta in un certo modo.

Una rappresentazione del significato per ogni voce

Ogni memoria, regola e skill esiste anche come rappresentazione calcolata di ciò che significa. Quando arriva una richiesta, anche questa viene trasformata nello stesso tipo di rappresentazione e confrontata direttamente con le altre.

È questa la parte che rende possibile la corrispondenza tra lingue diverse. Un prompt in turco fa emergere una memoria scritta in inglese quando le due condividono un'idea ma nemmeno una parola. Una ricerca per parole chiave non può farlo, perché non c'è alcuna stringa comune su cui trovare una corrispondenza. Il confronto avviene in uno spazio in cui "the payment webhook retries twice" e "ödeme webhook'u iki kez deniyor" si trovano vicini.

Le voci vengono rappresentate di nuovo quando il loro contenuto cambia, così la corrispondenza riflette ciò che la voce dice adesso e non ciò che diceva quando è stata creata.

Una finestra misurata attorno a ogni consegna

Quando Pathrule consegna conoscenza per un turno, apre un registro di quella consegna. Il registro contiene quali voci sono state inviate, su quale percorso e per quale tipo di intento.

Il turno poi riporta i propri dati nella stessa finestra:

• quali delle voci consegnate l'assistente ha effettivamente consultato, invece di limitarsi a riceverle
• quante chiamate a strumenti ha richiesto il turno e quante sono fallite
• quali file sono stati modificati, in forma relativa al workspace
• come si suddividono i fallimenti, sotto forma di codici brevi e non di testo d'errore

Questa finestra è la materia prima di tutto ciò che segue. È anche il motivo per cui Pathrule riesce a distinguere un turno andato bene da uno andato male senza che nessuno debba dare un voto.

Pesi appresi, per tipo di lavoro

Le finestre si accumulano. Col tempo ogni voce acquisisce una posizione per ciascun tipo di lavoro in cui è stata consegnata, e questa posizione si sposta in base alle evidenze: sale quando la voce è stata consultata in un lavoro filato liscio, scende quando è stata consegnata in un turno che ha incontrato difficoltà.

Ne consegue che la priorità non è un unico numero per voce. La stessa memoria può avere priorità alta per una migrazione e bassa per una piccola modifica all'interfaccia, perché sono tipi di lavoro diversi e le evidenze sono diverse. Un singolo campo "importanza" in un file non può esprimerlo, e chi dovesse mantenerlo a mano sarebbe costretto a tirare a indovinare.

L'apprendimento è volutamente prudente. Un esito ambiguo non insegna nulla invece di insegnare la cosa sbagliata, un singolo errore evidente abbassa la posizione senza cancellare la storia, e l'influenza si attenua man mano che il codice cambia. Come il recupero trova la conoscenza giusta descrive questo comportamento in dettaglio.

Un grafo dei file che si muovono insieme

A partire dai percorsi riportati dai turni, Pathrule costruisce un quadro di quali file il tuo team modifica abitualmente nello stesso lavoro. La conoscenza associata a uno di quei file può così raggiungere una sessione che lavora sul file vicino.

Nessuno dichiara queste relazioni e nessun file viene aperto per trovarle. Emergono dal lavoro registrato, hanno una soglia minima di rumore perché una singola coincidenza non conti, e decadono quando l'abbinamento smette di verificarsi. In un workspace Cloud il grafo parte anche con un vantaggio: la prima volta che un agente chiede contesto approfondito, viene inizializzato con i percorsi dei file della cronologia git recente, così è utile prima ancora che il tuo team abbia registrato molto lavoro. Vedi file che cambiano insieme.

Una mappa degli attriti

I fallimenti si raggruppano in una terna: il tipo di strumento, il file e un codice breve che indica come è fallito. Raggruppati per settimana, diventano un quadro di dove e come un assistente continua a bloccarsi nella tua codebase, e alimentano la priorità come segnale negativo quando un turno che ha ricevuto conoscenza ha comunque incontrato problemi. Vedi file che rallentano un assistente.

Una misura di quanto l'instradamento fosse corretto

Ogni prompt riceve anche un instradamento: i percorsi in cui con più probabilità si trova il lavoro, indicati prima che l'assistente apra qualsiasi cosa. Pathrule registra poi se l'assistente ci è andato davvero. Su una finestra mobile questo diventa un unico valore di accuratezza, affiancato da quanto lavoro sugli strumenti per i file richiede una sessione instradata rispetto a una che non lo è mai stata.

È l'unico numero che dice se indicare un percorso aiuta davvero e non sembra soltanto utile, ed è il motivo per cui l'instradamento può essere regolato in base alle evidenze invece che al gusto personale.

Ogni livello segnala se riceve ancora dati

Ciascuno dei livelli derivati descritti sopra dipende dal lavoro che vi confluisce, e un livello che smette di ricevere dati non restituisce nulla. Questo appare esattamente come un livello che non ha niente da riportare. I due casi richiedono risposte opposte, quindi Pathrule non li lascia apparire uguali.

A ogni livello viene chiesto regolarmente quando ha ricevuto dati l'ultima volta, e la risposta viene registrata come uno di tre stati: aggiornato, nessun dato di recente, oppure mai alimentato. Lo stesso controllo rileva i turni che arrivano da un client così vecchio da precedere una parte del registro, così un aggiornamento che vale la pena installare compare come un conteggio esplicito e non come risultati peggiorati in silenzio.

Ecco perché un livello derivato che tace è uno stato segnalato e datato, e non qualcosa che qualcuno nota mesi dopo chiedendosi perché un risultato sia peggiorato.

Episodi e giudizi sulla freschezza

Altri due livelli derivati poggiano sulla stessa attività.

Gli episodi di lavoro uniscono turni correlati nella storia di come è stato risolto qualcosa, così la domanda "come l'abbiamo fatto l'ultima volta" ha una risposta che non dipende dai ricordi di una persona. Vedi come l'abbiamo risolto l'ultima volta.

I giudizi di obsolescenza confrontano ciò che una voce afferma con la direzione che il codice ha preso nel frattempo, e propongono come modifiche quelle che sembrano superate invece di abbassarne in silenzio la priorità. Vedi suggerimenti e autoverifica.

Preferenze personali, conservate sulla tua macchina

Un livello parte da te e non dal lavoro registrato. Quando dici a Pathrule come preferisci lavorare, per esempio pathrule me teach "I prefer incremental refactors", il modello on-device opzionale trasforma la frase in una preferenza breve e con un ambito definito. Viene salvata sulla tua macchina, non caricata, e consegnata ai tuoi agenti dove serve.

Il controllo resta a te: pathrule me list mostra cosa è in uso, pathrule me explain mostra da dove proviene una preferenza, pathrule me scope la limita a un solo workspace oppure la applica a tutti i workspace, pathrule me forget ne interrompe l'uso e pathrule me context mostra in anteprima cosa riceverebbe un agente per un'attività. Vedi User Intelligence.

Da cosa non è costruito nulla di tutto questo

Non dal contenuto del tuo codice sorgente. Il codice sorgente del repository non viene caricato automaticamente. Ogni livello derivato descritto sopra nasce da ciò che il tuo team ha scelto di scrivere e da ciò che il lavoro ha riportato su sé stesso, e non viene salvato alcun diff né alcun messaggio di commit.

Dal tuo checkout vengono lette due cose, entrambe solo in un workspace Cloud ed entrambe la prima volta che un agente chiede contesto approfondito:

• I percorsi dei file dalla cronologia git recente, per capire quali file sono cambiati nello stesso commit. I commit molto grandi, di solito refactoring o rinomine, vengono saltati. Le coppie di percorsi di file risultanti vengono salvate nel workspace come punto di partenza del grafo dei file modificati insieme. Messaggi di commit, autori e diff non vengono letti.
• I nomi dei file vicini alla radice dell'albero delle cartelle, per riconoscere le tecnologie in uso dai file di configurazione, come una configurazione TypeScript, Vite, Docker o GitHub Actions. Ogni tecnologia riconosciuta diventa una breve memoria nella radice del workspace, scritta senza chiedere conferma. È una memoria come le altre, che puoi modificare o eliminare.

Finché la cronologia propria del workspace è ancora scarna, la stessa risposta approfondita indica anche le cartelle di primo livello del progetto e i file modificati più spesso nella cronologia git recente. Questi vengono letti dal tuo checkout e passati all'agente per quella risposta, ma Pathrule non li salva.

Un workspace locale, conservato sulla tua macchina senza account, non fa nulla di tutto questo: il suo grafo dei file modificati insieme proviene solo dal lavoro registrato.

In modalità Cloud lasciano la tua macchina altre due cose, ed entrambe sono indicate qui:

• L'inizio di ogni prompt. La prima parte del prompt, circa i primi 1.000 caratteri, viene inviata a Pathrule Cloud per stabilire la priorità della conoscenza da fornire.
• Uno snapshot del progetto, quando tu o il tuo agente eseguite pathrule snapshot. Carica l'albero dei file, i manifest, brevi estratti della documentazione e i metadati git recenti. Viene eseguito solo quando lo invochi.

La scansione del progetto è un passaggio separato che avvii tu, chiedendo al tuo agente di configurare Pathrule per il progetto. Il tuo agente legge il progetto per proporre memorie, regole e skill, e viene salvato solo ciò che approvi.

Inoltre, una CLI gestita con accesso effettuato può inviare telemetria d'uso anonima solo dopo che hai dato il consenso con pathrule telemetry enable. Non contiene codice, percorsi, prompt, conoscenza, nomi di file, email o id di account. pathrule telemetry disable, NO_TELEMETRY=1 e DO_NOT_TRACK=1 la mantengono disattivata.

I percorsi dei file vengono normalizzati in forma relativa al workspace prima che qualsiasi cosa venga conservata, quindi non viaggia nemmeno nulla di specifico della tua macchina.

Perché gli stessi file in una cartella non sono la stessa cosa

Potresti mettere le stesse memorie, regole e skill in una directory e indirizzarci un assistente. Ci sono team che lo fanno. Quello che una directory non può fare è tutto ciò che è descritto in questa pagina.

Non sa cosa è stato consegnato nell'ultimo turno, quindi non può capire cosa è stato utile. Non ha alcuna rappresentazione del significato, quindi una domanda formulata in modo diverso non trova nulla. Non sa quali file si muovono insieme, quindi la conoscenza registrata su un file non raggiunge mai il suo vicino. Non sa distinguere un tipo di attività da un altro, quindi tutto ha la stessa priorità per qualsiasi cosa. E cresce: ogni voce aggiunta appesantisce ogni turno futuro, perché una directory non ha modo di inviare solo le poche voci che contano.

Le voci scritte sono la parte che controlli tu. Il livello derivato è ciò che le trasforma nelle poche giuste per questo turno, ed è il motivo per cui la risposta migliora man mano che il lavoro prosegue, invece di restare esattamente buona come il giorno in cui è stata scritta.