@pulsarinteractive/geniustasker 0.1.0-beta.17 → 0.1.0-beta.18
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +6 -0
- package/README.md +1 -1
- package/docs/CHATGPT.md +7 -0
- package/docs/CLI.md +28 -1
- package/docs/DOCUMENTATION_SYNC.md +8 -0
- package/docs/INTEGRATIONS.md +4 -4
- package/docs/MEMORY.md +90 -8
- package/docs/WORKFLOWS.md +8 -0
- package/examples/codex.toml +1 -1
- package/examples/mcp.json +1 -1
- package/mcp.json +1 -1
- package/package.json +1 -1
- package/plugin.json +1 -1
- package/remote/tool-catalog.json +492 -3
- package/remote/workflows.json +196 -4
- package/skills/geniustasker/SKILL.md +9 -0
- package/skills/geniustasker-documentation/SKILL.md +5 -0
- package/skills/geniustasker-memory/SKILL.md +31 -5
- package/skills/geniustasker-planning/SKILL.md +5 -0
- package/src/archive.d.mts +1 -0
- package/src/archive.mjs +96 -0
- package/src/cli.mjs +87 -0
- package/src/client.mjs +6 -0
- package/src/command-catalog.mjs +20 -0
- package/src/command-input-schemas.mjs +102 -0
- package/src/documentation-sync.mjs +23 -2
- package/src/mcp.mjs +43 -2
- package/src/memory-editorial.d.mts +5 -0
- package/src/memory-editorial.mjs +216 -0
- package/src/memory-history.mjs +45 -0
- package/src/memory-read-pages.d.mts +4 -0
- package/src/memory-read-pages.mjs +221 -0
package/remote/workflows.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"formatVersion": 1,
|
|
3
|
-
"version": "2026-11-
|
|
3
|
+
"version": "2026-11-19",
|
|
4
4
|
"topics": {
|
|
5
5
|
"connection": {
|
|
6
6
|
"title": "Connection, permissions and language",
|
|
@@ -37,12 +37,15 @@
|
|
|
37
37
|
"Use project.update for ordinary project settings and project.features for planning switches, with projects:write and native administration rights. project.features is a full configuration: read and preserve all seven booleans and timeZone. It cannot change agent opt-in, membership, ownership or counters. project.delete requires project ownership, a current revision and an explicit user deletion request.",
|
|
38
38
|
"For an explicit request to set up or revise agent instructions, discover project.configureInstructions and inspect command_help. Only the actual project owner may replace instructions; projects:write, current scope grant, agentsEnabled=true and the current project revision remain required. Send only instructions (complete replacement, at most 12000 characters; empty explicitly clears). Preserve unrelated human guidance and exclude credentials/unrelated private context. Retain the exact operation after uncertainty, then read project.agentInstructions and unchanged agentsEnabled. This pending source addition requires compatible client and service; if unavailable retain the text and explain the gap, without private API fallback. Instructions do not grant permissions.",
|
|
39
39
|
"For sprint/workflow/recurrence lifecycle use the planning guide. For project documents use document.create/update/delete and folder.create/update/delete; these are separate from Memory. Folders use parent and documents use folder. Prevent duplicate names, preserve unrelated contents and read the current revision before moving or deleting.",
|
|
40
|
-
"For small steps of one deliverable read workflow checklist. Use separate tickets for independent ownership, dependency, deadline or estimate. Check/uncheck is an explicit desired boolean; no XP, push, auto-Done or resumption follows a checked item. Discover connected-service support first; client installation alone is insufficient."
|
|
40
|
+
"For small steps of one deliverable read workflow checklist. Use separate tickets for independent ownership, dependency, deadline or estimate. Check/uncheck is an explicit desired boolean; no XP, push, auto-Done or resumption follows a checked item. Discover connected-service support first; client installation alone is insufficient.",
|
|
41
|
+
"When starting work, check the project's documentation preference and linked Memory if available. At a verified milestone, evaluate which durable user-facing rule, behavior or decision changed. Use workflow memory-editorial before suggesting or applying an update. Completing a task, by itself, never authorizes publishing its contents."
|
|
41
42
|
]
|
|
42
43
|
},
|
|
43
44
|
"memory": {
|
|
44
45
|
"title": "Memory folders, documents and resources",
|
|
45
46
|
"steps": [
|
|
47
|
+
"At the start of real project work, inspect the project's linked Memory, documentation policy and the permission for that exact space, when advertised. Use workflow memory-editorial for deciding whether to update a note, suggest the first page, or leave the task as its only record. Workflow memory-reading covers multi-page reads. Workflow memory-templates offers optional starting pages.",
|
|
48
|
+
"Delegated Memory access requires an active Starter or Pro account plus grants and current resource rights. This includes documents, history, assets and Graph. On memory_premium_required stop delegated reads and writes. Recheck current access after a downgrade or revocation before using previously seen content.",
|
|
46
49
|
"Projects and Memory are independent spaces. List memories, inspect pageIndex or the tree, then fetch specific pages. Search before adding duplicate documentation. Preserve folder parentId and stable page/block IDs.",
|
|
47
50
|
"Read the page current revision and use memory.page.create/update/delete for both documents and folders. A folder is a page with directory:true, a stable id/path and parentId; child pages reference that ID. Preserve visibility/readRoles, stable block IDs and content not requested for modification. A parent or Graph link does not bypass current document permissions.",
|
|
48
51
|
"In ChatGPT use the available bounded memory/knowledge read tools and memory edit commands. Prepare with tasker_prepare_command, retain the complete immutable object and execute/retry with tasker_edit_memory. Hosted ChatGPT has no local journal or tasker_retry_command; local MCP uses that operation-ID tool and CLI uses commands retry. Repository documentation mirroring and local file upload are CLI/local MCP operations, not hosted connector filesystem access.",
|
|
@@ -54,7 +57,7 @@
|
|
|
54
57
|
"graph": {
|
|
55
58
|
"title": "Graph nodes, relations and revoked references",
|
|
56
59
|
"steps": [
|
|
57
|
-
"Graph creation, node/edge edits and delegated Graph reads/search/exploration require Starter or Pro for the acting user in addition to the normal grant; a paid space owner does not upgrade a collaborator.
|
|
60
|
+
"Graph creation, node/edge edits and delegated Graph reads/search/exploration require Starter or Pro for the acting user in addition to the normal grant; a paid space owner does not upgrade a collaborator. Delegated documents and media also require the connected account’s paid plan and their own page-level rights. On memory_graph_premium_required stop Graph calls rather than switching tools/profiles. Ordinary application sync and personal-data export remain available after downgrade. Do not copy Graph data into pages to bypass the restriction.",
|
|
58
61
|
"Read the relevant graph or a bounded neighborhood instead of crawling every space. Nodes have types and independent data; edges express typed relations. Use exact node IDs and inspect existing relations before adding duplicates.",
|
|
59
62
|
"Use memory.node.create/update/delete and memory.edge.create/update/delete with current revisions. Preserve imageAssetId, detailLevel, provenance and source references unless the user requested a change.",
|
|
60
63
|
"Resolve cross-space references through the authorized reference tool. If a friend removes access, the node and its own content may remain while the linked data is unavailable. Never delete the node or paste cached private data as a workaround.",
|
|
@@ -111,7 +114,8 @@
|
|
|
111
114
|
"An expired lease means stale reporting, not known failure or blockage. Tasker neither starts an agent nor observes an uninstrumented process. Never promise always-on operation. Respect cancellation_requested, TakenOver and Superseded; human control remains in the app and cannot be impersonated through MCP.",
|
|
112
115
|
"Use run.finish with Completed, Failed or Cancelled and truthful summary/evidence. It ends the run, not the task. Complete the task through run.patch only after verified intended work. After lease expiry, only a final result on the unchanged claim under its original user/profile may close it; task patches stay refused. A deleted task permits only Failed or Cancelled under current project permissions. Do not infer XP, task completion or device display from a run receipt.",
|
|
113
116
|
"Keep immutable operations and original identity after an uncertain result. Local CLI/stdio retain a journal; hosted ChatGPT must retain the exact command object. Reread after a definitive conflict and after finish or human takeover: the task revision changes as a server concurrency barrier without changing its content. New work after expiry requires current authority and an explicit fresh claim; never bypass human takeover. History is bounded: checkpointCount may exceed retained checkpoints.",
|
|
114
|
-
"For an explicitly instrumented local host, use CLI runs event --file or local MCP tasker_run_event with one saved eventId/occurredAt, current scope/run identity and revision, and a sanitized real summary. --prepare/prepareOnly only journals. process_exited maps to NeedsReview and requires nextSteps, never Task Done. No daemon, polling, log/environment/argument capture or host-hook installation is implied. Hosted ChatGPT uses prepared run commands through the task edit tool instead."
|
|
117
|
+
"For an explicitly instrumented local host, use CLI runs event --file or local MCP tasker_run_event with one saved eventId/occurredAt, current scope/run identity and revision, and a sanitized real summary. --prepare/prepareOnly only journals. process_exited maps to NeedsReview and requires nextSteps, never Task Done. No daemon, polling, log/environment/argument capture or host-hook installation is implied. Hosted ChatGPT uses prepared run commands through the task edit tool instead.",
|
|
118
|
+
"When a run verifies a lasting change, consult the project’s documentation preference and workflow memory-editorial. Link the evidence and any updated page to the work when permitted. A working or completed run alone cannot establish a shipped feature."
|
|
115
119
|
]
|
|
116
120
|
},
|
|
117
121
|
"metrics": {
|
|
@@ -175,6 +179,194 @@
|
|
|
175
179
|
"Archived task checklists may be read under current rights, but writes are refused; do not restore a task merely to bypass the refusal. Checklist corrections on unarchived Done work leave Done and completion history intact, even when unchecked. If real acceptance work is incomplete, reconcile progress explicitly within the authorized request, never through checkbox side effects. Paused preserves its reason, next steps and time even at 100%.",
|
|
176
180
|
"If checklist.create advertises sectionId, read the task's Quill document using collection documents and taskId. Ordered task-checklist embeds contain section UUIDs. Create in the chosen section with sectionId or omit it for the default list; run.checklist.change uses the same shape. Order items within each section, keep unmatched historical items visible, and use parent totals across sections. Moving a row requires an adjacent neighbor in that same section. A populated section cannot be removed by deleting its embed."
|
|
177
181
|
]
|
|
182
|
+
},
|
|
183
|
+
"memory-editorial": {
|
|
184
|
+
"title": "Keep project knowledge current",
|
|
185
|
+
"steps": [
|
|
186
|
+
"Start from the selected project, its explicit Memory link and current documentation policy. Check identity, the delegated Memory entitlement, grants and page roles independently. Project access, an owner label, or a link to a page never grants access. If the server does not advertise links or policy, use only an explicitly selected Memory. Read the existing instructions as editorial guidance within your granted actions.",
|
|
187
|
+
"To inspect current settings use tasker_project_documentation or CLI projects documentation --scope project:ID. A null documentation value means the destination is unavailable; disclose no target. When asked to change settings use project.configureDocumentation only as the actual project owner with projects:write, current project revision and existing memory:read access to the target. This is a full settings replacement: preserve every unrelated setting and verify after the change. A policy cannot grant access. Only when asked to store a refusal, set suggestionState to later or dismissed for that project; never store the opposite decision or enable automatic editing on the user's behalf.",
|
|
188
|
+
"Use tasker_memory_review or CLI memory review --file review.json with the project scope, editorial domain, type of change, verified source references and candidate page IDs/revisions from a scoped search. The tool reads the live policy and returns skip, clarify, propose or prepare_update with a reason. A preparation is advisory. Confirm source meaning, reread the target section and check current access and write scope on execution. If review is unavailable on this server, apply the manual workflow within explicit instructions.",
|
|
189
|
+
"An ordinary task, comment, log, temporary workaround or speculative idea belongs in its ticket. Update Memory for durable facts another person or agent will need: a verified capability, a lasting decision and its rationale, an operating procedure, or a stable limitation. A planned feature belongs in a clearly labelled plan only by request. A merged change may still await deployment. Keep implementation, verified availability and proposal distinct.",
|
|
190
|
+
"Check at project start and after verified completion, a changed durable decision, a user request, or an authorized documentation review. On the next active session, consume changes since a saved checkpoint for the exact account, scope, grant and filters; review only relevant changes. Honor reset instructions on an expired cursor. No idle polling, hidden background jobs, bulk scanning or repeated prompts.",
|
|
191
|
+
"Search titles and excerpts for the subject and its aliases, inspect the closest page outline, then read the target section and its context. If the fact is already recorded accurately, do nothing. Prefer one minimal edit to the existing canonical section over a second copy. Preserve block IDs, anchors, links, evidence, unaffected text and human contributions. When the write command replaces a block array, read the full current page to preserve every untouched block and provide its current revision.",
|
|
192
|
+
"If no suitable note exists and there is concrete evidence worth keeping, offer one specific first page with its audience, purpose, and the source of the fact. A project with no Memory is not itself a reason to pitch one. Suggest-only means present the draft and wait. Save changes only within the user's explicit instruction or an enabled automatic policy that covers this exact scope and operation. An enabled policy does not create a link, grant, or destination. Respect later and do-not-ask choices and do not ask again on unrelated tasks.",
|
|
193
|
+
"Write in the target section's existing language, tone, register, point of view and degree of technical detail. Match local headings, terminology, Markdown/list conventions, units and citation style. In a bilingual note, each section keeps its own language; translate prose for the conversation only when useful. Publish a translation only when explicitly requested. Preserve quoted text, commands, identifiers, URLs, product terminology and code. For a new page prefer the configured editorial language, then consistent neighboring pages; ask if neither resolves an important ambiguity.",
|
|
194
|
+
"Follow command_help and the live schema. Prepare the smallest authorized mutation, retain it for idempotent retry, then read back the affected revision and section. Reference a non-sensitive stable source such as a reviewed task, a release or an approved public guide. Preserve private scope boundaries and verify any broader destination has permission to receive the source information. Conflicts require rereading and merging compatible changes; present contradictory changes to the user. Never infer publication from a local draft or an uncertain response.",
|
|
195
|
+
"For example, after a Fitness implementation passes a verified release test that changes how scheduled workouts start offline, search the linked usage note for offline workouts. Update its existing paragraph and release evidence under the configured policy. A ticket saying “fix offline start” with no tested behavior supplies no publishable result. For Tasker a verified change to checklist completion might update one existing checklist rule; the per-ticket progress belongs in Tasker."
|
|
196
|
+
]
|
|
197
|
+
},
|
|
198
|
+
"memory-reading": {
|
|
199
|
+
"title": "Select and compare Memory pages at project scale",
|
|
200
|
+
"steps": [
|
|
201
|
+
"Use the current user's capabilities and authorized Memory. Identify the exact project and linked library before listing pages. Search by topic or alias and use tree/pageIndex headings, paths and summaries. Follow authorized cursors and stop when the question has enough verified evidence. Search excerpts and folder indexes alone cannot support a claim about a page's whole content.",
|
|
202
|
+
"When memorySections is true in the current capabilities use tasker_memory_read_pages (CLI memory read-pages --file selection.json). Select one to five distinct page IDs in a single Memory with mode outline or blocks. For blocks optionally pass blockIds from the current outline. Each page costs an ordinary read; a batch runs at most two at once and returns at most 64 KiB of logical JSON. Standalone page/Markdown reads remain available. Connectors never read a repository mirror or personal on-disk files.",
|
|
203
|
+
"For a comparison across ten known pages, use two groups of five with the same scope, epoch and checkpoint. Read outlines first when relevant block IDs are unknown, then fetch only the sections needed. Reuse the same page selector, block IDs/order, revision, epoch and checkpoint with nextCursor to resume a partial page. Concatenate fragments by stable block ID and offset. Keep excerpts and a source map of page IDs, blocks and revisions. An unchanged result can validate content only from the same selection, access context and revision.",
|
|
204
|
+
"For a question in a 500-page library, run a few targeted searches and inspect the matching branches; narrow by topic and choose the relevant sections. If results are incomplete say so. A search hit count does not establish complete coverage, absence or authority. Do not enumerate all pages simply because the library is large.",
|
|
205
|
+
"Only for an explicitly exhaustive review or export, build a bounded manifest from authorized folders/pageIndex (stable page ID, revision and work status). Continue each inventory with its own cursor and checkpoint, then process selected sections in groups of at most five. Checkpoint progress as requested/available, complete, partial, unavailable, changed and deferred. Allow resumption at the next page/block; store source material only in a destination explicitly authorized by the user. For CLI repository mirrors use docs sync and its existing file protections.",
|
|
206
|
+
"An unavailable page is neither evidence of deletion nor proof it never existed. Retain only the missing selection and mark it unavailable. On a changed revision, reread context and reconcile; on a snapshot/access conflict discard that batch and restart discovery. On permission loss stop using previously obtained material. On a quota stop honor retryAfterSeconds/resetAt and preserve outstanding IDs; never bypass quotas with another token, connection, direct storage or unmetered export."
|
|
207
|
+
]
|
|
208
|
+
},
|
|
209
|
+
"memory-templates": {
|
|
210
|
+
"title": "Choose an optional starting page",
|
|
211
|
+
"steps": [
|
|
212
|
+
"Offer a template only for an actual knowledge need. Select one family and a single useful page. Let the user choose other pages separately. Preview the title, proposed sections, audience and source; apply the same memory-editorial write policy as for any other note. A template grants no permissions and creates nothing automatically.",
|
|
213
|
+
"Use tasker_memory_template or CLI memory template --family product --language fr to list choices. Pass page (CLI --page feature) to preview one title and suggested headings. No write occurs. Localized starting suggestions support en/fr; adapt a new draft to the project's actual editorial language before requesting approval.",
|
|
214
|
+
"Product/software: a feature guide may cover its verified behavior, prerequisites and constraints; a decision record may contain context, choice and rationale; an operations note may document a repeatable recovery or release procedure. For an already documented feature update the existing page with evidence.",
|
|
215
|
+
"Video game: offer a mechanic note with player action, rule and edge cases; a balancing decision with objective, tested value range and build evidence; or a production constraint with owner and applicable platform. Keep design concepts separate from tested mechanics.",
|
|
216
|
+
"Music: offer a track or release brief with the intended arrangement and independently confirmed credits; a recording process page with routing and reproducible session setup; or a decision about a mix with version and reason. Include private artist or rights information only with permission for that destination.",
|
|
217
|
+
"Free-form: choose the user's title and one relevant section or a blank note. Use the requested language for a new page and follow existing neighboring style. Keep stable editable blocks and evidence references. Omit empty headings, placeholder facts and unused categories; keep secrets, access tokens and transient work logs out of notes."
|
|
218
|
+
],
|
|
219
|
+
"templates": [
|
|
220
|
+
{
|
|
221
|
+
"family": "product",
|
|
222
|
+
"pages": [
|
|
223
|
+
{
|
|
224
|
+
"key": "feature",
|
|
225
|
+
"title": {
|
|
226
|
+
"en": "How the feature works",
|
|
227
|
+
"fr": "Fonctionnement de la fonctionnalité"
|
|
228
|
+
},
|
|
229
|
+
"sections": {
|
|
230
|
+
"en": ["Who uses it", "Verified behavior", "Limits"],
|
|
231
|
+
"fr": ["À qui elle sert", "Comportement vérifié", "Limites"]
|
|
232
|
+
}
|
|
233
|
+
},
|
|
234
|
+
{
|
|
235
|
+
"key": "decision",
|
|
236
|
+
"title": {
|
|
237
|
+
"en": "Product decision",
|
|
238
|
+
"fr": "Décision produit"
|
|
239
|
+
},
|
|
240
|
+
"sections": {
|
|
241
|
+
"en": ["Context", "Decision", "Rationale"],
|
|
242
|
+
"fr": ["Contexte", "Décision", "Motifs"]
|
|
243
|
+
}
|
|
244
|
+
},
|
|
245
|
+
{
|
|
246
|
+
"key": "operations",
|
|
247
|
+
"title": {
|
|
248
|
+
"en": "Operating procedure",
|
|
249
|
+
"fr": "Procédure"
|
|
250
|
+
},
|
|
251
|
+
"sections": {
|
|
252
|
+
"en": ["When to use it", "Steps", "Verification"],
|
|
253
|
+
"fr": ["Quand l’utiliser", "Étapes", "Vérification"]
|
|
254
|
+
}
|
|
255
|
+
}
|
|
256
|
+
]
|
|
257
|
+
},
|
|
258
|
+
{
|
|
259
|
+
"family": "game",
|
|
260
|
+
"pages": [
|
|
261
|
+
{
|
|
262
|
+
"key": "mechanic",
|
|
263
|
+
"title": {
|
|
264
|
+
"en": "Gameplay mechanic",
|
|
265
|
+
"fr": "Mécanique de jeu"
|
|
266
|
+
},
|
|
267
|
+
"sections": {
|
|
268
|
+
"en": ["Player action", "Rule", "Edge cases"],
|
|
269
|
+
"fr": ["Action du joueur", "Règle", "Cas particuliers"]
|
|
270
|
+
}
|
|
271
|
+
},
|
|
272
|
+
{
|
|
273
|
+
"key": "balance",
|
|
274
|
+
"title": {
|
|
275
|
+
"en": "Balance decision",
|
|
276
|
+
"fr": "Décision d’équilibrage"
|
|
277
|
+
},
|
|
278
|
+
"sections": {
|
|
279
|
+
"en": ["Objective", "Tested build", "Decision"],
|
|
280
|
+
"fr": ["Objectif", "Version testée", "Décision"]
|
|
281
|
+
}
|
|
282
|
+
},
|
|
283
|
+
{
|
|
284
|
+
"key": "production",
|
|
285
|
+
"title": {
|
|
286
|
+
"en": "Production constraint",
|
|
287
|
+
"fr": "Contrainte de production"
|
|
288
|
+
},
|
|
289
|
+
"sections": {
|
|
290
|
+
"en": ["Affected platform", "Constraint", "Reason"],
|
|
291
|
+
"fr": ["Plateforme concernée", "Contrainte", "Motif"]
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
]
|
|
295
|
+
},
|
|
296
|
+
{
|
|
297
|
+
"family": "music",
|
|
298
|
+
"pages": [
|
|
299
|
+
{
|
|
300
|
+
"key": "track",
|
|
301
|
+
"title": {
|
|
302
|
+
"en": "Track brief",
|
|
303
|
+
"fr": "Fiche du morceau"
|
|
304
|
+
},
|
|
305
|
+
"sections": {
|
|
306
|
+
"en": ["Arrangement", "Confirmed credits"],
|
|
307
|
+
"fr": ["Arrangement", "Crédits confirmés"]
|
|
308
|
+
}
|
|
309
|
+
},
|
|
310
|
+
{
|
|
311
|
+
"key": "recording",
|
|
312
|
+
"title": {
|
|
313
|
+
"en": "Recording setup",
|
|
314
|
+
"fr": "Configuration d’enregistrement"
|
|
315
|
+
},
|
|
316
|
+
"sections": {
|
|
317
|
+
"en": ["Signal path", "Session settings"],
|
|
318
|
+
"fr": ["Chaîne du signal", "Réglages de session"]
|
|
319
|
+
}
|
|
320
|
+
},
|
|
321
|
+
{
|
|
322
|
+
"key": "mix",
|
|
323
|
+
"title": {
|
|
324
|
+
"en": "Mix decision",
|
|
325
|
+
"fr": "Décision de mixage"
|
|
326
|
+
},
|
|
327
|
+
"sections": {
|
|
328
|
+
"en": ["Version", "Decision", "Reason"],
|
|
329
|
+
"fr": ["Version", "Décision", "Motif"]
|
|
330
|
+
}
|
|
331
|
+
}
|
|
332
|
+
]
|
|
333
|
+
},
|
|
334
|
+
{
|
|
335
|
+
"family": "freeform",
|
|
336
|
+
"pages": [
|
|
337
|
+
{
|
|
338
|
+
"key": "note",
|
|
339
|
+
"title": {
|
|
340
|
+
"en": "Untitled note",
|
|
341
|
+
"fr": "Note sans titre"
|
|
342
|
+
},
|
|
343
|
+
"sections": {
|
|
344
|
+
"en": [],
|
|
345
|
+
"fr": []
|
|
346
|
+
}
|
|
347
|
+
}
|
|
348
|
+
]
|
|
349
|
+
}
|
|
350
|
+
]
|
|
351
|
+
},
|
|
352
|
+
"memory-history": {
|
|
353
|
+
"title": "Inspect or restore a Memory note revision",
|
|
354
|
+
"steps": [
|
|
355
|
+
"Check memoryHistory in capabilities for history/diff and memoryRestore for restore. Missing capabilities on an older deployment require using the supported current-page tools. Start with the active page and verify its current grant, role and revision. Use tasker_memory_history (CLI memory history) to list one page of retained revisions with available author/source metadata. Continue with nextBeforeRevision for the same page. A missing older revision may have expired; do not claim a complete lifetime audit.",
|
|
356
|
+
"Compare two retained revisions using tasker_memory_diff (CLI memory diff). The returned fields and changed block excerpts are bounded. Preserve distinct human and agent attribution; absent metadata supplies no identity. A temporary content restriction or revoked grant applies to history as well.",
|
|
357
|
+
"Restore only after an explicit request for the exact version. Re-read its diff and current page before offering or preparing the restore; disclose which content the selected revision would restore. Preserve the current page's access, links and placement. Never treat reading history, inspecting an old version or having write permission as authorization to restore.",
|
|
358
|
+
"For a confirmed restore, use the same scope, pageId, epoch, selected revision, expectedRevision, operationId and issuedAt on every retry. A stale revision needs a fresh read and explicit resolution of any intervening contributions. Read the active page and history back after success."
|
|
359
|
+
]
|
|
360
|
+
},
|
|
361
|
+
"archives": {
|
|
362
|
+
"title": "Look up previous work in a project archive",
|
|
363
|
+
"steps": [
|
|
364
|
+
"Use archived tasks for a past decision, ticket or evidence when the current project needs it. A normal working session uses active tasks. Historical data loads on demand. Discover effective tasks:read and history:read for this selected project and check server support for the archive routes.",
|
|
365
|
+
"Existing grants keep their original permissions. If a read is denied, explain which permission is missing and let the owner authorize a new or updated delegation. Never switch into an unscoped export, another transport, a privileged account or an all/active filter to retrieve restricted history.",
|
|
366
|
+
"Use tasker_archive_query or CLI archive query --file criteria.json with a project scope. Select text, archive dates, importance, status, assignees (or unassigned), shared filter and optional column. Dates refer to archive time; omit unknown constraints. A result is a bounded selection; an empty page can still have a next continuation. Keep the exact filters, project and returned cursor unchanged on each new call.",
|
|
367
|
+
"Fetch only the chosen task using tasker_archive_detail, then the relevant comments with tasker_archive_comments. CLI equivalents are archive detail and archive comments. Continue comments using nextAfter, scoped to this exact task and project. Stop when the available evidence answers the question, report actual coverage and keep the material within the allowed project audience.",
|
|
368
|
+
"If the project, access or query checkpoint changes, restart the bounded discovery. Honor account reads, retry delays and resetAt. Archived tasks contribute to the owning account’s storage. Paid accounts retain archives; Free has a maximum 90-day retention policy. An unavailable record may have expired, been restored or become inaccessible; never infer which from absence alone."
|
|
369
|
+
]
|
|
178
370
|
}
|
|
179
371
|
}
|
|
180
372
|
}
|
|
@@ -203,3 +203,12 @@ saved operation ID. After a conflict, reread before preparing a new operation.
|
|
|
203
203
|
Successful edits use the application’s normal realtime path. Verify the server
|
|
204
204
|
result, but do not claim another device has displayed it unless observed. Do not
|
|
205
205
|
start a polling loop or prescribe a manual refresh as the normal workflow.
|
|
206
|
+
|
|
207
|
+
At project start and after verifying a durable feature or decision, check the
|
|
208
|
+
linked Memory and documentation preference. Read the [Memory skill](../geniustasker-memory/SKILL.md)
|
|
209
|
+
and workflow `memory-editorial` to decide whether to update an existing note,
|
|
210
|
+
propose a first note, or leave the information in the task.
|
|
211
|
+
|
|
212
|
+
To investigate historical work, use workflow `archives`. Search one project's
|
|
213
|
+
archive, follow its bounded continuation and fetch only the relevant task and
|
|
214
|
+
comments. Both `tasks:read` and a current `history:read` grant are required.
|
|
@@ -37,3 +37,8 @@ the node’s own notes. A removed managed snapshot cannot erase previous Git cop
|
|
|
37
37
|
Read [the recommended structure](references/structure.md) when organizing new
|
|
38
38
|
knowledge. For configuration and recovery commands, consult the packaged
|
|
39
39
|
`docs/DOCUMENTATION_SYNC.md` or its canonical public repository page.
|
|
40
|
+
|
|
41
|
+
When reconciling new evidence into a source note, follow workflow
|
|
42
|
+
`memory-editorial`. Preserve the language and style of each section, stable
|
|
43
|
+
anchors, links and human edits. Use `memory-reading` for bounded source review
|
|
44
|
+
and track which selected pages were actually covered before reporting completion.
|
|
@@ -3,7 +3,10 @@ name: geniustasker-memory
|
|
|
3
3
|
description: Read and maintain GeniusTasker Memory documents and Graph relations through the connected CLI or MCP. Use for knowledge search, structured documents, linked nodes and authorized imports. Memory access remains independent of project and Graph access.
|
|
4
4
|
---
|
|
5
5
|
|
|
6
|
-
|
|
6
|
+
Delegated document, history, media and Graph operations require an active
|
|
7
|
+
Starter or Pro plan and explicit access to the target. Stop on
|
|
8
|
+
`memory_premium_required` and discard protected content after revocation.
|
|
9
|
+
Memory belongs to the account and can be linked to several projects. Use the user's
|
|
7
10
|
selected context and environment; discover identity and capabilities first.
|
|
8
11
|
If no session exists, ask the user to run `geniustasker auth login --context work`
|
|
9
12
|
in their terminal with the intended environment. The beta defaults to development;
|
|
@@ -12,12 +15,24 @@ CLI/MCP invocations. Use a distinct context; its name alone does not select an
|
|
|
12
15
|
environment. The browser lets them select resources and permissions.
|
|
13
16
|
Do not collect passwords or tokens, approve your own consent, or edit credentials.
|
|
14
17
|
|
|
18
|
+
## Decide when a note should change
|
|
19
|
+
|
|
20
|
+
Read `tasker_workflow` topic `memory-editorial` when starting project work,
|
|
21
|
+
closing a verified milestone, or maintaining a feature guide. Check the project's
|
|
22
|
+
linked Memory, policy and explicit resource grants. Look for one existing note
|
|
23
|
+
to update before offering a specific first page. Respect deferred and declined
|
|
24
|
+
suggestions. Write each section in its existing language and editorial style.
|
|
25
|
+
Use topic `memory-templates` only when choosing an optional starting page.
|
|
26
|
+
|
|
15
27
|
## Navigate without loading the entire corpus
|
|
16
28
|
|
|
17
29
|
1. Call `tasker_identity` and `tasker_capabilities` (CLI `whoami`, `capabilities`).
|
|
18
30
|
2. Use `tasker_memories` / `memories list`. Follow `nextAfter`, including empty pages.
|
|
19
31
|
3. When `documentationSync` is advertised, use `tasker_memory_tree` to navigate folders and compare branch versions. Otherwise read `tasker_resources` with `collection: pageIndex`.
|
|
20
|
-
4.
|
|
32
|
+
4. On a service supporting note sections, use `tasker_memory_read_pages` (CLI
|
|
33
|
+
`memory read-pages --file selection.json`) for a maximum of five particular
|
|
34
|
+
pages. See workflow `memory-reading` for continuations and coverage at scale.
|
|
35
|
+
Fetch the needed `pages` by `id` or `path`. Targeted reads do not return a change cursor.
|
|
21
36
|
5. Use `tasker_search` (`memory search`) to find page or node excerpts. Read the
|
|
22
37
|
full record before editing; an excerpt does not establish the full context.
|
|
23
38
|
|
|
@@ -25,12 +40,24 @@ Carry `epoch` and `checkpoint` from the first page when continuing an inventory.
|
|
|
25
40
|
An index omits page bodies; it is not evidence of their contents. After context
|
|
26
41
|
change, restart the read. Access denial is not permission to switch accounts.
|
|
27
42
|
|
|
43
|
+
For an explicitly exhaustive review of hundreds of pages in an approved local
|
|
44
|
+
directory, use CLI `docs sync` or local MCP `tasker_docs_sync`. If throttled,
|
|
45
|
+
report `progress.preparedPages / selectedPages` for the selected scope and
|
|
46
|
+
respect the reset time. Repeat the same selection and directory; the client
|
|
47
|
+
checks revisions and permissions before reusing downloads. With hosted MCP,
|
|
48
|
+
keep a manifest of page IDs, revisions and block cursors in the approved work
|
|
49
|
+
record. The hosted connector never creates a local snapshot.
|
|
50
|
+
|
|
28
51
|
For a large library, cross-memory questions or resumable maintenance, read
|
|
29
52
|
[focused knowledge workflows](references/knowledge-workflows.md). It explains
|
|
30
53
|
how to combine search, Graph neighborhoods and targeted pages without downloading
|
|
31
54
|
every space. The client revalidates its bounded resource cache on every access;
|
|
32
55
|
it never treats an offline or refused request as a successful cached read.
|
|
33
56
|
|
|
57
|
+
For inspecting a revision or deliberately restoring its text, follow workflow
|
|
58
|
+
`memory-history`. Restoring requires an explicit instruction, a preview of the
|
|
59
|
+
diff, fresh access and an exact expected revision.
|
|
60
|
+
|
|
34
61
|
## Maintain editable, trustworthy knowledge
|
|
35
62
|
|
|
36
63
|
Keep pages focused and use stable paths. Preserve block IDs for existing content.
|
|
@@ -72,9 +99,8 @@ deployments may not expose them. Nodes and edges live in a memory scope. Read
|
|
|
72
99
|
(`graph explore`) around a selected node rather than reading the entire graph.
|
|
73
100
|
`truncated` means the result is incomplete. Never infer absent relations from it.
|
|
74
101
|
|
|
75
|
-
Graph
|
|
76
|
-
|
|
77
|
-
attachments remain independent. On `memory_graph_premium_required`, stop Graph
|
|
102
|
+
Graph also enforces its per-resource rights. Documents and their attachments
|
|
103
|
+
have their own per-page and media permissions. On `memory_graph_premium_required`, stop Graph
|
|
78
104
|
calls; do not switch tools, profiles or copy it into documents to bypass the tier.
|
|
79
105
|
|
|
80
106
|
Each node owns its editable text; references contain only scope, pageId and an
|
|
@@ -85,3 +85,8 @@ For a requested focus or temporary deferral, read `tasker_workflow` topic
|
|
|
85
85
|
These instructions belong to the connected owner and do not change a task's
|
|
86
86
|
status, schedule, reward or execution claim. Resolve timezone before an end time;
|
|
87
87
|
never silently replace a larger group or apply an instruction to a collaborator.
|
|
88
|
+
|
|
89
|
+
At project start and after verifying a durable feature or decision, check the
|
|
90
|
+
linked Memory and documentation preference. Read the [Memory skill](../geniustasker-memory/SKILL.md)
|
|
91
|
+
and workflow `memory-editorial` to decide whether to update an existing note,
|
|
92
|
+
propose a first note, or leave the information in the task.
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export function archiveQuery(input: unknown): Record<string, unknown>;
|
package/src/archive.mjs
ADDED
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
import * as z from 'zod/v4';
|
|
2
|
+
import tools from '../remote/tool-catalog.json' with { type: 'json' };
|
|
3
|
+
import { fail } from './errors.mjs';
|
|
4
|
+
|
|
5
|
+
export const archiveTools = new Map(
|
|
6
|
+
['query', 'detail', 'comments'].map((key) => {
|
|
7
|
+
const tool = tools.find((entry) => entry.name === 'tasker_archive_' + key);
|
|
8
|
+
return [key, { tool, schema: z.fromJSONSchema(tool.inputSchema) }];
|
|
9
|
+
}),
|
|
10
|
+
);
|
|
11
|
+
|
|
12
|
+
export function archiveQuery(input) {
|
|
13
|
+
const parsed = archiveTools.get('query').schema.safeParse(input);
|
|
14
|
+
if (!parsed.success) {
|
|
15
|
+
fail('invalid_arguments', 'Choose one project and valid archive filters.');
|
|
16
|
+
}
|
|
17
|
+
const {
|
|
18
|
+
scope,
|
|
19
|
+
limit = 25,
|
|
20
|
+
query = '',
|
|
21
|
+
statuses = [],
|
|
22
|
+
assignees = [],
|
|
23
|
+
importance,
|
|
24
|
+
archivedFrom,
|
|
25
|
+
archivedUntil,
|
|
26
|
+
sort = 'Newest',
|
|
27
|
+
sharedFilterId = null,
|
|
28
|
+
column = null,
|
|
29
|
+
continuation = null,
|
|
30
|
+
} = parsed.data;
|
|
31
|
+
if (archivedFrom && archivedUntil && Date.parse(archivedFrom) > Date.parse(archivedUntil)) {
|
|
32
|
+
fail('invalid_arguments', 'The archive interval must start before it ends.');
|
|
33
|
+
}
|
|
34
|
+
return {
|
|
35
|
+
scope,
|
|
36
|
+
limit,
|
|
37
|
+
criteria: {
|
|
38
|
+
formatVersion: 1,
|
|
39
|
+
query,
|
|
40
|
+
tags: [],
|
|
41
|
+
allTags: false,
|
|
42
|
+
assignees,
|
|
43
|
+
statuses,
|
|
44
|
+
priorities: [],
|
|
45
|
+
sprints: [],
|
|
46
|
+
epics: [],
|
|
47
|
+
placement: null,
|
|
48
|
+
blocked: null,
|
|
49
|
+
},
|
|
50
|
+
sort,
|
|
51
|
+
sharedFilterId,
|
|
52
|
+
column,
|
|
53
|
+
continuation,
|
|
54
|
+
archive: true,
|
|
55
|
+
...(importance ? { importance } : {}),
|
|
56
|
+
...(archivedFrom ? { archivedFrom } : {}),
|
|
57
|
+
...(archivedUntil ? { archivedUntil } : {}),
|
|
58
|
+
};
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
export async function readArchive(client, key, input) {
|
|
62
|
+
const entry = archiveTools.get(key);
|
|
63
|
+
const parsed = entry?.schema.safeParse(input);
|
|
64
|
+
if (!parsed?.success) {
|
|
65
|
+
fail('invalid_arguments', 'Use the archive selectors for this operation.');
|
|
66
|
+
}
|
|
67
|
+
let response;
|
|
68
|
+
if (key === 'query') {
|
|
69
|
+
response = await client.transport.request('/api/agents/v1/' + entry.tool.route, {
|
|
70
|
+
method: 'POST',
|
|
71
|
+
token: await client.accessToken(),
|
|
72
|
+
json: archiveQuery(parsed.data),
|
|
73
|
+
});
|
|
74
|
+
} else {
|
|
75
|
+
response = await client.get(entry.tool.route, parsed.data);
|
|
76
|
+
}
|
|
77
|
+
if (
|
|
78
|
+
response?.scope !== parsed.data.scope ||
|
|
79
|
+
(key === 'query' &&
|
|
80
|
+
(response.module !== 'Project/ProjectTask' ||
|
|
81
|
+
!Array.isArray(response.items) ||
|
|
82
|
+
response.items.length > (parsed.data.limit ?? 25) ||
|
|
83
|
+
!(response.next === null || typeof response.next === 'string'))) ||
|
|
84
|
+
(key !== 'query' && response.id !== parsed.data.id) ||
|
|
85
|
+
(key === 'detail' &&
|
|
86
|
+
(typeof response.revision !== 'string' ||
|
|
87
|
+
!response.data ||
|
|
88
|
+
typeof response.data !== 'object')) ||
|
|
89
|
+
(key === 'comments' &&
|
|
90
|
+
(!Array.isArray(response.items) ||
|
|
91
|
+
!(response.nextAfter === null || typeof response.nextAfter === 'string')))
|
|
92
|
+
) {
|
|
93
|
+
fail('invalid_response', 'The archive response did not match the requested task or page.');
|
|
94
|
+
}
|
|
95
|
+
return response;
|
|
96
|
+
}
|
package/src/cli.mjs
CHANGED
|
@@ -12,6 +12,14 @@ import {
|
|
|
12
12
|
uploadFeedbackImage,
|
|
13
13
|
downloadFeedbackImage,
|
|
14
14
|
} from './feedback-media-transfer.mjs';
|
|
15
|
+
import { readArchive } from './archive.mjs';
|
|
16
|
+
import {
|
|
17
|
+
readProjectDocumentation,
|
|
18
|
+
reviewProjectMemory,
|
|
19
|
+
previewMemoryTemplate,
|
|
20
|
+
} from './memory-editorial.mjs';
|
|
21
|
+
import { memoryHistoryRequest } from './memory-history.mjs';
|
|
22
|
+
import { readMemoryPages } from './memory-read-pages.mjs';
|
|
15
23
|
import { workflow, workflowTopics } from './workflows.mjs';
|
|
16
24
|
import { readFile } from 'node:fs/promises';
|
|
17
25
|
import {
|
|
@@ -181,6 +189,43 @@ export const commands = {
|
|
|
181
189
|
summary: 'Read one folder and descendant versions; unchanged validators avoid page bodies.',
|
|
182
190
|
options: ['scope', 'parent', 'after', 'epoch', 'checkpoint', 'if-none-match'],
|
|
183
191
|
},
|
|
192
|
+
'archive query': {
|
|
193
|
+
summary: 'Search one project archive with bounded filters from a JSON file.',
|
|
194
|
+
options: ['file'],
|
|
195
|
+
},
|
|
196
|
+
'archive detail': {
|
|
197
|
+
summary: 'Read one archived task with historical access.',
|
|
198
|
+
options: ['scope', 'id'],
|
|
199
|
+
},
|
|
200
|
+
'archive comments': {
|
|
201
|
+
summary: 'Read one page of comments for the selected archived task.',
|
|
202
|
+
options: ['scope', 'id', 'after'],
|
|
203
|
+
},
|
|
204
|
+
'memory review': {
|
|
205
|
+
summary: 'Evaluate verified evidence against the live documentation policy. Reads only.',
|
|
206
|
+
options: ['file'],
|
|
207
|
+
},
|
|
208
|
+
'memory template': {
|
|
209
|
+
summary: 'List optional pages in a family or preview one selected page.',
|
|
210
|
+
options: ['family', 'page', 'language'],
|
|
211
|
+
},
|
|
212
|
+
'memory history': {
|
|
213
|
+
summary: 'Read a page of retained revision metadata for an authorized note.',
|
|
214
|
+
options: ['scope', 'page', 'before-revision'],
|
|
215
|
+
},
|
|
216
|
+
'memory diff': {
|
|
217
|
+
summary: 'Compare changed fields and block excerpts between retained revisions.',
|
|
218
|
+
options: ['scope', 'page', 'from', 'to'],
|
|
219
|
+
},
|
|
220
|
+
'memory restore': {
|
|
221
|
+
summary: 'Restore a confirmed note revision using an immutable JSON request.',
|
|
222
|
+
options: ['file'],
|
|
223
|
+
},
|
|
224
|
+
'memory read-pages': {
|
|
225
|
+
summary:
|
|
226
|
+
'Read one bounded batch of selected page outlines or blocks. The JSON file contains scope, pages and optional snapshot.',
|
|
227
|
+
options: ['file'],
|
|
228
|
+
},
|
|
184
229
|
'memory markdown': {
|
|
185
230
|
summary: 'Fetch one portable Markdown document with stable media IDs and source metadata.',
|
|
186
231
|
options: ['scope', 'page', 'revision', 'epoch', 'checkpoint'],
|
|
@@ -198,6 +243,10 @@ export const commands = {
|
|
|
198
243
|
'Resolve a Memory page or block with current permissions; unavailable links preserve nodes.',
|
|
199
244
|
options: ['scope', 'page', 'block'],
|
|
200
245
|
},
|
|
246
|
+
'projects documentation': {
|
|
247
|
+
summary: 'Read the current editorial policy and its authorized target.',
|
|
248
|
+
options: ['scope'],
|
|
249
|
+
},
|
|
201
250
|
'projects list': {
|
|
202
251
|
summary: 'Read a bounded project page; follow nextAfter even for an empty page.',
|
|
203
252
|
options: ['after'],
|
|
@@ -597,6 +646,44 @@ export async function main(
|
|
|
597
646
|
checkpoint: options.checkpoint,
|
|
598
647
|
ifNoneMatch: options['if-none-match'],
|
|
599
648
|
});
|
|
649
|
+
} else if (command.startsWith('archive ')) {
|
|
650
|
+
const operation = command.split(' ')[1];
|
|
651
|
+
const input =
|
|
652
|
+
operation === 'query'
|
|
653
|
+
? await readCommandFile(options.file)
|
|
654
|
+
: {
|
|
655
|
+
scope: options.scope,
|
|
656
|
+
id: options.id,
|
|
657
|
+
...(options.after ? { after: options.after } : {}),
|
|
658
|
+
};
|
|
659
|
+
data = await readArchive(client, operation, input);
|
|
660
|
+
} else if (command === 'projects documentation') {
|
|
661
|
+
data = await readProjectDocumentation(client, { scope: options.scope });
|
|
662
|
+
} else if (command === 'memory review') {
|
|
663
|
+
data = await reviewProjectMemory(client, await readCommandFile(options.file));
|
|
664
|
+
} else if (command === 'memory template') {
|
|
665
|
+
data = previewMemoryTemplate({
|
|
666
|
+
family: options.family,
|
|
667
|
+
language: options.language,
|
|
668
|
+
...(options.page ? { page: options.page } : {}),
|
|
669
|
+
});
|
|
670
|
+
} else if (command === 'memory history') {
|
|
671
|
+
data = await memoryHistoryRequest(client, 'history', {
|
|
672
|
+
scope: options.scope,
|
|
673
|
+
pageId: options.page,
|
|
674
|
+
...(options['before-revision'] ? { beforeRevision: options['before-revision'] } : {}),
|
|
675
|
+
});
|
|
676
|
+
} else if (command === 'memory diff') {
|
|
677
|
+
data = await memoryHistoryRequest(client, 'diff', {
|
|
678
|
+
scope: options.scope,
|
|
679
|
+
pageId: options.page,
|
|
680
|
+
fromRevision: options.from,
|
|
681
|
+
...(options.to ? { toRevision: options.to } : {}),
|
|
682
|
+
});
|
|
683
|
+
} else if (command === 'memory restore') {
|
|
684
|
+
data = await memoryHistoryRequest(client, 'restore', await readCommandFile(options.file));
|
|
685
|
+
} else if (command === 'memory read-pages') {
|
|
686
|
+
data = await readMemoryPages(client, await readCommandFile(options.file));
|
|
600
687
|
} else if (command === 'memory markdown') {
|
|
601
688
|
data = await readMemoryMarkdown(client, {
|
|
602
689
|
scope: options.scope,
|
package/src/client.mjs
CHANGED
|
@@ -180,6 +180,9 @@ export class AgentClient {
|
|
|
180
180
|
'me',
|
|
181
181
|
'capabilities',
|
|
182
182
|
'projects',
|
|
183
|
+
'project/documentation',
|
|
184
|
+
'tasks/archive/detail',
|
|
185
|
+
'tasks/archive/comments',
|
|
183
186
|
'memories',
|
|
184
187
|
'resources',
|
|
185
188
|
'profiles',
|
|
@@ -189,6 +192,9 @@ export class AgentClient {
|
|
|
189
192
|
'reference',
|
|
190
193
|
'memory/tree',
|
|
191
194
|
'memory/markdown',
|
|
195
|
+
'memory/sections',
|
|
196
|
+
'memory/history',
|
|
197
|
+
'memory/diff',
|
|
192
198
|
].includes(resource)
|
|
193
199
|
) {
|
|
194
200
|
fail('invalid_arguments', 'Unknown delegated resource.');
|