Connect ChatGPT and execute actions

Private journal PC tasks — Preview → approve → execute

Check private journal intake on my registered default PC. Preview exact intake, transcription, draft or reviewed-publication effects first. Keep source bodies off the research server.

Daily research planning and check-in — Preview → approve → execute

Read my daily research briefing and review priorities and blockers. Show the content before saving or sharing.

Find materials and events — Read now

Find imagery EEG materials and summarize them with source links.

Check GitHub work — Read now

Show accessible open GitHub tasks and their last observed time.

Create a GitHub Issue — Preview → approve → execute

Show repositories where I can create an Issue, ask for its title and body, then preview it.

Schedule an event — Preview → approve → execute

Show available calendars, ask for the date, time and attendees, then preview the event.

Generate a report — Preview → approve → execute

Prepare a report for the last seven days, private to me, with no email. Ask for the grant and show a preview first.

Generate a private article — Preview → approve → execute

Prepare a research article draft. Ask for the lab, period and topic, then preview it without publishing.

Check generation progress — Read now

Check my recent generation jobs and whether their bodies are ready. Explain recovery for failed jobs.

Help and troubleshooting — Read now

Find a solution in LUNA help. If unresolved, prepare a support draft for my review.

Draft a bilingual notice — Review and submit on website

Prepare a bilingual notice draft and a web review link. Do not publish it.

Draft a support request — Review and submit on website

Draft a support request summarizing the problem and attempted fixes. Exclude secrets and research content; I will review and submit it.

Cloud and PC execution support and status — Read now

Show online operations and current registered-PC readiness for ANNA. Read execution using its existing ID; distinguish host exposure from actual completion.

Revise, build and privately save courses — Preview → approve → execute

Find my registered course and session, then preview these exact file edits. Preserve existing approvals, review term-wide private save effects, and verify the execution receipt.

Continue and save research work — Preview → approve → execute

Continue the current research work and save this discussion and delivered files to that same work. Identify a separate intent before creating new work.

Draft event and task wording — Preview → approve → execute

Prepare a draft for the next meeting in this research space. Show the target and cost first; do not register an event or send invitations.

Keep existing work — Preview → approve → execute

Bookmark the research work I am viewing in My saved items.

Research goals, literature and dossiers — Preview → approve → execute

Prepare a paper goal from the selected project and check attachment readiness. Show cost and changes before execution.

Code work, ablations and validation — Preview → approve → execute

Prepare a separate code workspace from this idea and show its validation plan and diff. Request approval before publishing.

Comments, chat, discussions and actions — Preview → approve → execute

Prepare a question for this material discussion. I will approve after reviewing the destination and body.

Action results and follow-ups — Preview → approve → execute

Read my action history and show responses to review. Show follow-up changes before saving.

1. Open Profile → Settings → ChatGPT connection and AI output settings for the enabled address and walkthrough.

2. In ChatGPT developer mode, add a Plugins connection using https://lunalab-ai.com/mcp, OAuth and DCR when offered. Availability depends on your account/workspace.

3. Review the LUNA account and read consent yourself. Do not enter API keys or DB passwords.

4. Select LUNA in a new ChatGPT conversation and search a title you can open in LUNA. Check search/fetch activity and actual source links.

Official connection guide: https://developers.openai.com/plugins/deploy/connect-chatgpt

A request URL is not a finished body. Check content_available, phase, completed_batches/total_batches, code and message with get_action_status. Large evidence sets are analyzed in batches, then combined. Automatic batches use one personal allowance unit per request; an explicit retry uses another. Retry a legacy limited/split_required job from its report page to resume the same report. Narrow requests above 500 sources to a project or researcher. Search follows current read access, report creation requires management permission, and platform administrators have broader access.

Use Share and collaborate on a strategy report to review content, recipients and read or follow-up permissions. Report ID and immutable edition ID/version preserve lineage. Original attachments, private chats and GitHub access are not automatically shared. Open Shared research reports, then start your own discussion or code workspace. Share a saved result with the team by selecting an exact revision/checkpoint/code result and files to return to the author. Seen, review and adoption are separate human actions. Sharing, reading and exporting make no AI call; new generation uses the initiating user’s allowance. Stable request IDs prevent duplicates. Revocation, expiry, withdrawal and project access changes affect subsequent access and continuation. Exported copies cannot be recalled. Notion queues a fixed edition under an authorized parent; unknown outcomes never auto-retry. Reconcile the existing page by ID. External researchers must first complete existing account and lab/project participation approval; member rollout is not automatically enabled.

Use consultant_thread_prepare(operation=save, values={space:{operation:read/graph/work_search/links/link_history,values:{space_id,...}}}) for the same canonical work. work_search accepts query and kind=work/all_work/strategy/record. Connect uses source and target as kind:ID, kind=derived/reference/requires/revision/produces/validates and an optional selector for the section or method. Add supports multiple data.relations entries containing source, kind and selector in one atomic save. Preview with the current revision and stable request_key, then commit the exact review and preview_token. Include link and link_revision for explicit refresh or disconnect. Prerequisites are not automatic execution instructions. Reuse the same thread for a continuing task; only delivered answers/files are preserved. Server support and host tool availability are separate.

In Create action, choose a method and type a destination name, title or issue number. Personal AI and ChatGPT use research_action_options with lab, kind and q, omitting target, to search the same destinations. Results contain six items; when has_more is true, pass next_offset as offset. An explicit kind and target still reads destination context. Search consumes no LUNA AI allowance and never posts or sends. Saving a draft and approving the execution preview are separate. Actual ChatGPT use requires host availability of the tool.

If personal account tools are not exposed yet, use consultant_thread_prepare(operation=save, values={memory:{operation:read,query?,offset?}}) to read your memory and settings_version. Review mutations with values={memory:{operation:prepare,settings_version,changes:{operation:save/forget/exclude/include/configure/reset,...}}}, then pass the exact returned preview_token and review to consultant_thread_commit. Reads need no commit; changes require the current write scope. No new thread or paid AI call is required.

Ask “What do you remember about me?”, “Apply this preference only to this project”, or “Exclude this conversation from future recall.” Read memory through consultant_account_read, then review exact changes with consultant_account_prepare(section=memory) and commit. Use memory_query for retrieval and memory_offset for pagination. If the host has not exposed new arguments, continue on the Personal AI memory page. consultant_thread_read includes currently accessible personal context for the same work. Memory edits and retrieval invoke no additional model; conversation reasoning has its usual cost. LUNA cannot capture an entire ChatGPT account: only content delivered by supported storage tools is available. Private memories and conversations are never automatically shared with a team.

Choose automatic preservation or sync on request when linking a discussion. Reuse the same LUNA thread ID across prompts. Native answers follow that policy; Sync available discussion preserves up to 50 accessible unsynced native answers per request. External ChatGPT/Codex must actually deliver relevant answers/files through tools. Read sync status with consultant_thread_read, then use consultant_thread_prepare(operation=sync) and commit for configure/begin/chunk/finish/flush/confirm. Cached hosts can use operation=save, values={sync:{operation,values}}. Scoped automatic preservation consent covers intermediate saves, subject to host permission prompts. It never authorizes confirmation, publication, GitHub writes or paid generation. The same discussion page shows current and confirmed results and cumulative history. Transfer files in 48KB chunks, up to 8MB, with 120KB conversation text and stable retry keys. Claim saved only after the ready receipt. Unseen messages and expired files cannot be recovered automatically. Saving and version management require no extra AI calls.

Open Profile → Settings → ChatGPT connection and connect your own LUNA account. Select LUNA in ChatGPT and ask “Explain the LUNA features available to me.” Features either read information, execute after approval, or continue on the website. This guide covers server support; actual use also requires current permissions, external connections and host tool discovery. A missing tool is not a completed action. Continue on the corresponding platform page. Official connection guide: https://developers.openai.com/plugins/deploy/connect-chatgpt

Example: “Find recent experiment reports and open GitHub tasks for my project and summarize them with source links.” Specify the project, period and keywords. Search readable titles, bodies, events and tasks, then fetch selected sources. Check observation times and coverage. Missing results do not imply inactivity. Reads do not use LUNA generation allowance or grant access to another person’s private sources.

Example: “Read today’s notes and propose three goals. Show the original and changes before saving.” Read the current day and revision, then review and save goals, results, blockers and next steps. Saving is not external delivery. PI sharing separately reviews the grant, recipient and exact body. Mentions and document citations provide context, not permission to send messages. Per-item actions retain the saved item and exact revision.

Example: “Prepare a paper goal that can be validated in ten days using the selected project. Keep automatic analysis off.” Review and save goals, annual categories, actual submission/acceptance/publication dates, personal automatic caps and manual reserves. Strategy generation uses personal allowance. Read saved proposals and versions; start, pause or resume a detailed dossier. Review linked outputs and automation state when trashing/restoring a goal. Only platform administrators change the shared public-analysis budget. Status checks and downloads do not require regeneration.

Example: “Propose two ways to adapt the architecture on page 6 of the paper attached to my goal, with ablations.” First read the goal’s context, scope, constraints, sources and attachment readiness. Explicit document citations are prioritized; mentions identify people only. A ChatGPT upload is not a LUNA upload. If the current connection lacks a file-transfer tool, attach the file in the platform goal editor and continue using the goal ID. Goal context reads include prepared text passages; visual=true also returns the selected page image. Analyze extracted PDF text and the selected visual page without claiming to have read every figure.

Example: “Prepare a new code workspace from this proposal and design ablations that preserve the data loader.” Confirm the repository, base branch, goal and intent. Multiple workspaces may use one repository. Creating one only saves a record; it does not commit. The workspace title later becomes the commit and PR title. Attach files through the platform code editor; consultant_code_read returns preparation states and extracted evidence, and retry_inputs retries failed extraction without AI usage. Read code → choose a recommendation → implement/ablate → inspect files, documentation and checks → preview publication. Reuse other saved recommendations without regenerating. CPU checks are actual bounded tests, not GPU training or proof of improved performance. Imported local results are labeled owner-provided. A new branch/draft PR is the default; direct base-branch commits require review of the exact diff and baseline SHA. File/ZIP links require platform access.

Example: “Draft a comment asking for readiness on this Issue. Do not send it yet.” Select an authorized repository or issue, save a draft, and review the exact destination, body and acting account. After approval, create an issue, comment, file commit or PR. Check IDs and links because titles may repeat. If delivery is uncertain, inspect the existing receipt rather than creating another action. Successful delivery does not prove reading or completion.

Example: “Prepare a discussion comment asking about the experiment conditions below this report.” Select the conversation, direct recipient, material/report discussion or PI share destination. Review the audience and body before approving. Do not copy private source passages to a broader audience. Read delivery and subsequent replies from action history. A mention does not replace destination and preview checks.

Example: “Prepare last week’s report, private to me, without email.” Confirm grant, period, format and audience for reports; date, time, timezone and participants for events; and lab, period and topic for articles. Supported direct tools queue generation after preview approval. Website handoffs must be completed on that page. Article generation is not public publication. A queued link is not a completed body; check readiness and the actual result.

Example: “Prepare this proposal as manual work and a follow-up tomorrow.” Manual work records a private action without external publication. Report requests and responses may continue in prepared website forms. Enter results yourself or explicitly refresh linked responses; later sharing via a report/message requires a separate reviewed action. Keep self-reports, replies and your own follow-up confirmation distinct. These records inform the next AI review without declaring research success.

Example: “Prepare a bilingual feature announcement draft and a review link. Do not publish it.” Read permitted workflows and targets, then prepare a website review link. Notices require administrator authority and publication review on the website. Support drafts should include the problem, affected screen and attempted fixes, excluding secrets and research content. A link is not a published notice, submitted support request or delivered report request.

Help, saved-result reads and ordinary previews do not invoke new LUNA generation. AI recommendations, drafts, strategy and code use the displayed personal allowance; ChatGPT usage is separate. An AI recommendation “prepare” operation may spend allowance, so review its cost. Distinguish queued, preparing, analyzing, complete and failed, and re-read the same job ID. Never automatically retry an uncertain remote write. Web status refreshes about every eight seconds while active or thirty seconds while idle, pausing in hidden tabs. Disconnecting prevents future access but cannot recall delivered data. Official file contract: https://developers.openai.com/plugins/reference

Choose Continue discussion on a strategy, code result or report. Give ChatGPT the work ID to read its baseline, recent discussion, confirmed decisions and revisions. Example: “Add only two comparison experiments and preserve the rest.” Revisions are saved separately without overwriting publications or GitHub files. Exact-excerpt patches, previous-version selection and alternative branches preserve earlier work. Code may use a saved implementation/ablation as parent; untouched generated files are retained. Prior passing tests do not validate revised code. Only decisions and revisions saved through tools are shared, not your entire ChatGPT history. Use consultant_thread_list/read/prepare/commit; saving does not invoke platform AI.

Start a private research consultation from the bottom conversation dock: AI consultation, then New conversation. Ask AI in the help panel is for usage guidance, not research execution tools. Research AI consultation is processed independently of external collection. In follow-up work, Discuss answers questions; Create revised version explicitly saves a private Markdown version, without publishing or committing. For long documents, revise selected sections. In text-response mode in an unfiltered private consultation, request the same search, read, preparation and execution capabilities in natural language. One question may use up to three personal AI attempts to retrieve context and reason about it. Model-proposed changes become review cards; publication, commits and settings changes wait for approval. Additional AI generation has separate usage. Shared or source-filtered consultations retain their existing evidence boundary; use an unfiltered private consultation for the full tool set. Permission changes, changed baselines and uncertain outcomes require review, not blind retransmission.

Daily plan/review drafts use the administrator call-time policy. Shared daily allowance, daily research cap, per-request call budget and timeout are separate. Details and recovery shows the applied policy and linked attempts. Rejected responses are encrypted for up to 24 hours; revalidation uses no AI when current permissions and evidence still match, and never applies the draft to personal notes automatically. Retry proposes one additional AI call using current policy/evidence. Replaying the same approved review does not duplicate execution. A timeout without a received response does not claim saved output. Old failed responses that were never retained cannot be recovered. In ChatGPT read daily_drafts from consultant_brief. Use consultant_prepare save with daily_draft {run,operation:revalidate|retry}, show the returned review, and call consultant_commit only for the approved operation.

Continue directly from a new question or existing work in the space. The stable work URL /workspace/consultant/works/<work_id>/ opens the same work as the web panel on its own page. Copying the link grants no access; reading the page creates no work, conversation or AI request. When reviewing a particular report, code output or earlier version, preserve its result link and selected conversation and version. consultant_thread_prepare(operation=save, values={desk:{operation:read,values:{space_id,tab:home/work/results/schedule/trash,work?,query?,offset?}}}) reads currently authorized work, results and downloads. Use the returned work_id or kind:ID for work. Status accepts space_id and optional work for a small progress response. Read/status need no commit and create no work, conversation or AI request. Existing reports, code and goals retain their original IDs and ACL under the common work registry. Distinct analyses are not merged by title. Current conversation revisions and latest saved checkpoints represent the result; older versions stay in detailed history. Sharing or opening a link is not proof that answers or files were preserved. Never bypass blocked content or downloads.

For desk ask or note, supply space_id, question, a stable UUID request_key and the existing work. Omitting work creates private new work from the first question; reuse the returned work_id and thread afterward. Relations can provide multiple origins and references. Pass the exact reviewed review and preview_token to consultant_thread_commit. Ask requests a platform AI answer and uses allowance; note saves a private record without another model call. If ChatGPT has already produced an answer or files, deliver them through existing sync begin/chunk/finish on the returned thread instead of calling ask again. Use the current sync.revision, stable request_key and exact file manifest; claim saved only after a ready receipt. Undelivered external conversations are not automatically captured, and private conversations or source access are not automatically shared. Verify actual host tool availability and invocation separately.

Desk trash_work/restore_work takes space_id, work, its current lifecycle_revision as revision, and request_key. Trash_space/restore_space/reset/restore_reset uses the current desk revision, space_id and request_key; restore_reset also needs the target batch. Commit only the exact reviewed target and effects. Trash is not permanent deletion; reset archives earlier work as a previous cycle. Original reports, conversations, files, parent materials, members and external sources remain preserved. Execution is blocked while work is trashed or archived. Restoration itself queues no AI; original automation policy remains preserved, so an enabled policy may run at its next scheduled time after restoration. A call already dispatched to an external provider cannot be guaranteed recalled. Work individually trashed earlier stays trashed when restoring a cycle.

For new input attachments, use desk upload_policy/upload_begin/upload_chunk/upload_finish/upload_read to preserve up to 50 files totaling 100 MB in chunks. Follow returned chunk_bytes, actual sizes and SHA256 hashes, and stable request keys. Poll preparation and supply completed attachment IDs to ask or note on the same work. Generated output files use the same 100 MB/50-file original transport. Without a linked space, use upload_begin with inbox=true, then pass returned file IDs as content.stored_files to capture.save. With a space, connect those same IDs to the current work. resolve(fallback=inbox) chooses the private inbox when no destination is known; invalid explicit destinations and revoked permissions still fail. The existing 8 MB inline checkpoint route remains a compatibility transport for small files, not the overall output-file limit. Downloads stream preserved originals. Hosts follow host_chunk_bytes. Preserving input is not a claim that AI has read every original. Review exact content, files and audience through desk share_publish/share_withdraw before commit. Read/ask/note with audience=team on the same work and deliver outputs to the returned thread. Do not include private source conversations or personal memory as team evidence. Actual external host tool support and byte transfer require separate verification.

Use consultant_thread_prepare(operation=save, values={space:{operation:team_read or team_search,values:{space_id,query?,offset?}}}) to read members and eligible candidates. team_add accepts users, optional roles, access, revision and request_key. team_update uses user, roles and access; team_end uses user; team_configure reviews name, description and parent settings under the same revision and request_key contract. Show the exact members and access, then pass the returned review and preview_token to consultant_thread_commit. Every surface uses the same space ID and rechecks current permissions. Adding an existing member cannot overwrite access; authorship never elevates access. Reading or editing roles invokes no AI and sends no invitation. Copying a report link preserves its identity and language without granting access. Verify actual tool availability in the host separately.

Use consultant_thread_prepare(operation=save, values={compose:{operation,values}}) for the shared composer. inputs and suggestions only read sources and saved suggestions within space_id and the chosen work/thread/result/audience. Selecting a suggestion neither executes AI nor adopts work. After editing returned question and relations, pass selection_token in desk.ask/note compose_selections to bind the original suggestion to the single actual saved work. Only when explicitly requested, draft/refine reviews and commits question, request_key, space_id and selected evidence/attachments. It uses one private AI wording call and starts no research work or external action. Poll compose.read(space_id,run), then preserve provenance with refine_run on the final send. Host-written wording can be edited and sent without this extra call. Preserve existing ChatGPT results with capture.save instead of triggering another AI request. Verify actual host tool availability and delivered file bytes from receipts.

Continue in ChatGPT prepares copyable text from the final edited question and selected materials in both new and existing work. Read compose.handoff with consultant_thread_prepare(operation=save, values={compose:{operation:handoff,values:{space_id,request_key,question,work?,thread?,result?,relations?,attachments?,compose_selections?,refine_run?,audience?,language}}}). question is the current input and attachments contains verified completed-upload IDs. Never represent filenames or undelivered host files as preserved attachments. Current permissions and the exact work, conversation and output versions are rechecked, and preparation state is returned. Handoff is read-only: saved=false and ai_used=false, with no work, conversation, answer or external transfer created. Keep request_key for retries and choose the destination before creating new work. Do not claim analysis before actually reading the originals. If host tools are unavailable, continue on the website and do not claim preparation, delivery or saving occurred. Use existing capture/sync to preserve actually delivered replies/files and verify the completed receipt. Wording refinement, platform AI execution, broader sharing and publication have separate costs and approval boundaries.

The default graph folds strategy reports into their owning work. outputs=true explicitly expands exact report and code-result cards. Renaming changes the work display name without rewriting report content, versions or evidence, or duplicating work. Derivation and reference remain separate relations. When multiple report versions or selectors appear as one work link, its relations retain original source/target keys, hashes, revisions and relation IDs. scope describes currently displayed works, outputs and materials within a partial view, not collection totals. Never merge work IDs by list order or title. Read links/link_history for detailed relationships and deliberately refresh evidence only after current-access and exact-version checks. Reading the graph makes no AI call.

Read bibliography through consultant_thread_prepare(operation=save, values={literature:{operation,values}}). list accepts space_id,q?,page?,limit(3/20/50); detail accepts space_id,id. Search returned literature:UUID keys in compose.inputs and use them as reference relation sources so web, native AI and ChatGPT use the same versions and permissions. Example: “Find contrastive-learning references and pinned Zotero papers in this space, without generating new summaries.” export accepts space_id,format(bib/ris/json),scope(all/search/selected),q?,ids?,exclude_ids?. Use exact IDs for selected; use scope=search with exclude_ids to select all matches except specific papers. Use returned content, filename and count unchanged, and provide downloads only when the host actually creates a file. All means the entire authorized range, not the first page. Examples: “Create BibTeX for only the three selected papers” or “Export every search match as RIS and report the count.” This service performs no remote Zotero writes or PDF uploads.

literature.edit accepts space_id,id,revision,changes. changes uses CSL-JSON fields such as title,author,issued,container-title,DOI,URL and abstract. Use given/family for people or literal for organizations, and issued.date-parts or literal for dates. null removes a space override and restores the source field. Review the exact before/after and pass returned review and preview_token unchanged to consultant_thread_commit. Example: “Correct only the publication year, preserving the Zotero original and earlier reports.” Editing names or DOI retains paper IDs and work references. Review pin(id,revision,active) under the same permissions. summary uses one AI request to store a summary and a separate space-purpose relevance assessment. Read summary.relevance text/category (direct, partial, unclear) and stale; preserve the original source assessment. It accepts id,revision,request_key,language(ko/en),regenerate? and queues a platform AI request only after explicit review and commit. Never call summary on browse, collection, pin or export. Prefer an original abstract; body summaries require accessible preserved text. Original abstracts remain separate from AI summaries and research relevance. Answering in the host differs from requesting LUNA generation. “Show the abstract” is a read; “Request a LUNA AI summary and check completion” is an explicit metered generation.

Use continuation_mode=same or new in desk.ask/note and compose.handoff/native_handoff. same appends request/result pairs to the same work; new creates derived work from the selected originating work/output version on actual save. Preparing or copying creates nothing. Reuse request_key for retries and never duplicate work by result or title. Saved requests retain a settled default-condition snapshot. Work-menu conditions and conversational refinement share kind-specific fields while applying a draft and changing defaults remain distinct. Flow sorting places downstream causal work first without turning references into execution dependencies. Literature, code or training classifications and saved conditions never authorize GPU execution or GitHub commits. Distinguish “Check another assumption inside this work” from “Create separate implementation work from this exact output version.”

Inspect source_proofs, current hash and code_links for source versions and code provenance. A public code URL proves neither official implementation, reuse permission, environment readiness nor successful execution. Model-design and implementation requests should connect paper IDs, chosen methods, pinned source commits, target repositories/branches and validation plans. Example: “Verify the paper and official-code evidence, then propose only changes for our project; do not commit or train yet.” Always verify which implementation, upload and execution tools the host actually exposes. Preserve only actually delivered results/files through capture; a source URL is not a preserved downloadable file. Training, server execution and independent reproduction have separate capabilities and authorization scopes.

When adding references in a linked work, pass context={work,thread?,question,channel:chatgpt,audience,continuation:same} through consultant_material_prepare or the existing consultant_thread_prepare save/materials envelope. Registration and its delivered request/result are saved atomically; reuse request_key for retries. If the destination is unclear, use capture.resolve for current bindings and concrete candidates, then ask the user. Never guess by title. Unresolved details may be preserved in a private inbox draft without executing or sharing research. For an earlier unlinked receipt, review materials operation=link_history with its request_key and context. Do not register papers again or reconstruct unseen conversation. Example: “Link the registration I just completed to the current literature-review work.” To attach a PDF, review literature operation=attach_pdf with values={space_id,id,revision,request_key,file_id,version_kind}, then commit. file_id must identify a completed upload, not a filename or temporary URL. Use published, preprint or supplement. Example: “Attach this newly found PDF to the existing reference and preserve earlier files.” Native private consultation supplies its linked work and actual question. Team consultation uses fixed shared-work tools and evidence accessible to every current participant. Report only saved text and actually transferred files as complete; distinguish unavailable transfer and partial completion.

For diagnostics. Host discovery must be verified separately.

search

fetch

source_connection_status

search_work_items

list_my_generation_jobs

list_workflows

prepare_workflow

search_materials

search_help

read_help

action_options

prepare_action

get_action_status

quick_help

render_quick_help

create_github_issue

create_calendar_event

generate_report

generate_article

consultant_brief

consultant_prepare

consultant_commit

consultant_strategy_list

consultant_strategy_read

consultant_strategy_prepare

consultant_strategy_commit

consultant_code_list

consultant_code_read

consultant_code_prepare

consultant_code_commit

consultant_thread_list

consultant_thread_read

consultant_thread_prepare

consultant_thread_commit

consultant_account_read

consultant_account_prepare

consultant_account_commit

consultant_account_usage

consultant_account_contributions

consultant_account_diagnose

consultant_material_prepare

consultant_material_status

consultant_material_commit

consultant_work_read

consultant_work_status

consultant_literature_list

consultant_literature_read

consultant_literature_evidence

consultant_literature_export

consultant_literature_edit_preview

consultant_literature_metadata_preview

consultant_literature_visibility_preview

consultant_literature_pdf_preview

consultant_literature_summary_preview

consultant_literature_commit

consultant_files_import

consultant_files_status

consultant_files_import_pdf_url

consultant_capture_resolve

consultant_capture_save_preview

consultant_capture_commit

consultant_capture_read

consultant_zotero_destinations

consultant_zotero_prepare

consultant_zotero_commit

consultant_zotero_status

consultant_workspace_capabilities

consultant_workspace_status

consultant_workspace_prepare

consultant_workspace_commit

consultant_journal_options

consultant_journal_prepare

consultant_journal_commit

consultant_journal_status

research_action_options

research_prepare_action

research_action_list

research_save_draft

research_preview_action

research_action_status

research_refresh_results

research_update_followup

research_post_github_comment

research_create_github_issue

research_send_chat

research_send_direct

research_post_discussion

research_share_pi_report

research_commit_file

research_create_pull_request

research_record_manual_work

research_open_report_form

research_open_calendar_form

research_open_request_form

research_open_response_form

research_open_code_workspace

research_open_report_editor

teaching_options

teaching_prepare

teaching_commit

teaching_status

teaching_list

teaching_cancel

Use only tools available in your current connection.

Examples: “Show the original request and saved parts”, “Resume the failed stage.” Use consultant_strategy_read with status/history/analysis; prepare and approve analyze or analysis_pause/analysis_resume/analysis_cancel before changes. New analysis defaults to four stages with a four-attempt cap. Web and native consultation share the same IDs and outputs. Reads use no platform AI; generating a conversational answer may use allowance.

Ask “Show my remaining AI allowance and reset time”, “Show my contribution score”, or “Show my administrator-managed execution policy”. Shared account tools read current settings and prepare an exact before/change review. Execution policy changes require current platform administrator authority and explicitly review the effect on all users. Personal overrides are rejected. Other settings remain personal; sharing rights and publication remain separate. Tools: consultant_account_read, prepare, commit, usage, contributions and diagnose. Help AI can read current personal settings and usage. Continue to work/settings consultation carries the question into private full consultation; subsequent reasoning uses personal AI allowance and changes require review. If the ChatGPT host does not expose a tool, check the connection and granted scopes.

New strategy analyses default to prior reports, feedback, saved follow-up decisions and recent discussions for the same goal. Originals remain available; bounded excerpts and omissions are recorded for model input. Independent analysis excludes prior analysis context. Revoked evidence is never reused. Code consultation from a report, section or action retains source provenance. ChatGPT resumes the same request ID and checkpoints; completed work uses follow-up analysis. analysis with status=true returns small metadata. Review strategy_prepare acknowledge with kind/id/version before commit. If the host exposes an old limit or missing operations, refresh the connected tools and read the central policy.

Each code workspace has one representative notice across preparation, AI and validation steps. Dismiss preserves failures and does not mark them successful. Link a strategy report under Sources and links; the report also links back to derived code. External results preserve the question, answer, files, provenance, versions and downloads. Ask ChatGPT or Codex to continue this LUNA workspace and save the answer and files to the same workspace. Only a ready storage receipt confirms synchronization. Conversations or temporary files never delivered to LUNA are not automatically imported. You can also paste an answer and select files in the platform. Conversation text is limited to 120 KB, files to 100 files and 8 MB total; retry with identical files and request identity to resume. Files are not executed; model and test claims are producer-reported. Revisions preserve previous results. Storage uses no new AI call but consumes storage and backup capacity. Encrypted rejected responses may be revalidated without AI for up to 24 hours; invalid responses remain failures. Execution/resume settings start collapsed.

Today/this week/this month/this year set date bounds in Asia/Seoul. Choose chart granularity separately in advanced filters. Administrators receive OpenAI Standard reference defaults checked on 2026-10-05. Custom rates and historical estimates are preserved. Long context, cache writes and processing tiers are distinguished; unknown tiers use an API-equivalent estimate, not subscription billing.

The live strip shows queued/running requests only. Analysis archives separate attention, completed, cancelled/failed and trash; saved outputs remain downloadable. Cancel before moving active work to trash; restore never resumes automatically. Permanent deletion requires an exact scope review and current permission, and rejects references from later consultations/code. Original attachments and usage totals remain. Old encrypted backups are not immediately erased; reapply the latest deletion ledger after restoration. ChatGPT uses consultant_strategy_prepare analysis_trash/analysis_restore/analysis_purge and commit.

Goal settings precede research context. Paginate all literature/search observations and reports. Deduplicated literature and per-search snapshots are separate; legacy observations have unknown original search batches. Only the final analysis stage creates a final report; partial results remain on the request. Compare two saved reports without AI. ChatGPT strategy_read collection=reports/literature/observations with goal,page reads the same lists.

Choose a project, repository and purpose using Start GitHub repository consultation on the code landing page. Continue an existing analysis where available. Consultation is expanded on the detail page and requires a completed repository read. Connection/permission problems link to connection settings. The current bound of 24 text files/85KB does not establish whole-repository verification.

Analysis detail shows unavailable evidence counts and Google reauthorization status. Open the linked connection, personally authorize Google, wait for collection, then check access again. Authorization alone never restores historical access. Reuse saved stages only after a new authorized collection confirms the same file, version and content. Changed content or revoked access keeps old results preserved but restricted. Review a new analysis with accessible evidence to create a separate four-stage request after reviewing the original question, budget and timeout. Blocked source text and old outputs are not copied; new calls consume the existing personal allowance. Preview/status reads never run AI. ChatGPT uses strategy_read analysis diagnosis and the exact strategy_prepare analysis_recover / strategy_commit review contract.

Use Manage limits in Today's research to open Daily usage limits in Platform AI management.

Administrators choose Follow overall AI allowance or Set a separate cap. Administrators inherit by default; the existing regular-user default remains 5. Inheritance is not extra credit: research shares the personal pool with translation, help and other AI. A separate cap of 0 disables research AI.

Manage my overall daily AI allowance opens per-user overall limits. Attempted runs, queued reservations, completed and failed runs and reset times are distinct.

The overall pool resets at Seoul midnight; a separate research cap resets at midnight in the research timezone. Per-request budgets and per-call timeouts remain separate execution settings. Raising limits never clears history or usage, or automatically retries failures.

In ChatGPT or AI consultation, read research_usage via consultant_account_read. Only administrators can review and commit execution changes to research_daily_limit/admin_research_daily_limit; null inherits the overall pool.

Use the automation control at the top of a paper goal without deleting it. Conditions are collapsed by default. Periodic review offers None, daily, every three days, weekly and fortnightly. None disables periodic review only; new literature, changed evidence and deadlines within seven days are independent triggers. Disable automation to stop every automatic trigger. Literature discovery is separate and does not consume personal AI attempts. Disabling cancels unstarted automatic requests; a started call may incur its existing cost and save a validated result before stopping. Manual analyses, reports, literature and history remain. Enabling or changing conditions schedules future work without replaying missed periods. Allowance waits, failure holds and running states are distinguished; the next review time is an estimate. Ask ChatGPT or AI consultation to disable automation for the goal. consultant_strategy_read returns automation and its revision; prepare(operation=goal, values={automation_revision, automation:{automatic:false}}), review the exact change, then commit updates the same policy. Actual host tool exposure must be verified separately. Reading and saving policy do not execute an AI analysis.

Editing goal settings preserves discovered papers, analysis links and observations. Titles and deadlines do not change the search revision; changing search terms does. Accumulated literature is the default, with filters for current, earlier or unknown settings, recent discovery, analysis availability and relevance review, paginated by 20. Unknown historical search terms are never inferred. Prioritize, select by relevance and exclude apply to future analyses without deleting previous results. Reassess relevance after changing the question or research scope. Reads and selection saves spend no AI allowance; automatic analysis consent is separate. consultant_strategy_read(goal) returns the same library in ChatGPT and AI consultation. prepare(operation=goal, values={literature:{operation:list,filter:all,page:1}}) is read-only. For changes, use literature operation=select, paper, inclusion(auto/include/exclude) and revision, review, then commit. Search observations retain the actual terms and settings.

Use the top share icon for team sharing or Notion publication. Find recipients by name and use ? for field help. For Notion, select an allowed parent and review the body before queuing publication. Configure a connection if none is available. Notion audiences are independent. The export icon provides full-body print, PDF and Markdown. An uncertain publication is reconciled, never blindly reposted.

Connected tools support reading a goal workflow and recording notes or imported results. Use the lifecycle envelope inside consultant_thread_prepare save, followed by reviewed commit for changes. Only transmitted content is saved. Reads and record writes do not invoke extra AI or remote experiments; new consultation follows existing usage policy.

AI source suggestions in Materials & results works without pins. The website reads saved suggestions first; only generating fresh ones requests one AI attempt. In ChatGPT, first verify that this host exposes consultant_thread_prepare, then read with operation=save, values={material_recommendations:{operation:read,values:{space_id,run?}}}. Read returns currently authorized candidates without AI. Inspect title, reason, coverage, provider, url and pin_state. Prepare operation:recommend with space_id, request_key and optional language; review source scope and the expected one AI attempt, then pass the returned preview_token and review to consultant_thread_commit. Operation:study with a sources list of material IDs prepares a composer link with evidence and invokes no AI. Pinning uses the existing space.pin contract for the current private/team scope. Selecting, pinning and sending research are separate actions. Never claim support for unavailable host tools or that unread full text has been checked.

New public-paper bibliography is visible by default to active signed-in platform users, not anonymous visitors. PDF originals, private analysis and research spaces retain their existing access. Reusing an existing private source does not publish it. Edit bibliographic fields and grant/project/researcher metadata on the permanent literature page. External Zotero originals are not overwritten.

Example: “Find references in this space that lack a PDF. Locate public originals, verify the title and DOI, and attach them to the existing references while preserving earlier files.” Tools import a public HTTPS PDF or an actually transferable ChatGPT file and verify bytes, size and hash. They never bypass login or paid access. Original preservation, text preparation and AI analysis are separate states; an unavailable file transfer is not a saved result.

Example: “Compare these three papers for the Paper Goal and Literature Survey work. State the PDF version and actual coverage; tabulate model structure, data, metrics and limitations. Save the delivered analysis as another request/result pair in this same work and attach the comparison file.” The existing work ID and earlier results are preserved. An excerpt is never labelled a complete-paper reading. Specify explicitly when a new derived work is intended.

Example: “Save the actual image and BibTeX files just created as outputs of this work. Report each saved status and download link.” Attach up to 50 files, combined 100 MB. Reuse the request key for retries; reselect files to renew expired transfer links. The file tool must actually be available in the ChatGPT host. If unavailable, transfer the files through Add sources on the platform. A filename or temporary link is not a preserved file.

Search, select required references or all references, then use the download icon beside search for BibTeX, RIS or CSL JSON. Example: “Correct the selected authors and DOI while preserving the original.” AI summaries run only after a button action or explicit request. Applying the refinement preview updates both the current composer and its local draft, ready to inspect before sending. Dashed graph edges indicate references; solid edges indicate research flow.

In the existing work composer, use Add sources to select one reference or PDF. Enter a goal-specific question, choose Paper analysis and discovery in the Send to AI menu, and send. Source reading, backward/forward/topic search, registration, synthesis and manuscript drafts are checkpointed. Search uses the public paper title or your explicit public query, not private goals. Verified references and final recommendations are registered automatically; PDF collection is queued with actual storage status. Missing originals limit analysis to the abstract. Forward and similar searches cover the first 25 results each; request further searches separately. Paywalls and institutional login are not bypassed; unavailable originals retain a reason. Registration, original collection, AI analysis and author review are separate states.

Use work menu → Research conditions to edit the question, venue, deadline and constraints. Expand Collaborative guidance to opt into a reviewed goal snapshot and next-action notifications. Only the published goal version is shared; private edits do not silently replace it. Notifications open the same suggestion ID used by the composer and do not execute AI. Deferred or dismissed suggestions are not resurrected. Before joint use, check work sharing, access to originals and the shared goal separately. Approved methods also require use and provider-processing permission. Participants use the research team destination for follow-up analysis. Private results are not published automatically. A researcher confirms submission or goal completion.

Use work menu → Know-how settings to select exact approved versions. The default direction and relevant common/activity guidance are pinned; four stages are not required for every work. Existing work-only know-how remains available in collapsed history. Select currently accessible, non-deleted request/result evidence and distinguish paper-specific fixes from reusable improvements. Compare against the actual active v1 using matched input/model/work conditions, held-out input and human review receipts before considering v2 promotion. Promotion changes future defaults and is reversible; it does not rewrite existing results. The built-in method before initialization is distinct from a reviewed and evaluated v1. Method versions, manuscript revisions and model IDs are distinct. Output-only use, source reading and derivation are separate permissions.

The author or an authorized space manager can move an accessible request/result pair to trash through its menu. Removed content is excluded from new analysis, method improvement and downloads; other researchers’ follow-ups and existing quotations remain. Restore through Deleted requests and results; this never restarts AI. Management does not grant access to another person’s private conversation. External copies and provider costs already incurred are unaffected.

Continue in ChatGPT preserves the same work ID and selected evidence, saving only delivered results. Survey request/status/resume/external, method reads/improvements and pair delete/restore reuse consultant_thread_prepare/commit reviews. Independent host analysis never claims to have executed a protected method. Core instructions are excluded from ordinary results, history and exports. Provider processing permission is reviewed separately; this does not guarantee that outputs cannot reveal or imply knowledge. Download the draft and BibTeX, review them, then incorporate them in Overleaf; there is no automatic bidirectional sync. Per-request, daily and provider limits pause work while preserving completed stages. Inspect saved stages and usage before explicitly resuming. Team consultation tools currently support requests and status; use the web for resuming and method management. Host tool availability, new server PDF collection, AI quality and Lightsail latency require separate verification.

In the same work composer, ask: “Separate the literature-analysis and manuscript-writing know-how from this discussion. Propose only the changes to each existing method.” Only delivered, saved requests and results are evidence. External ChatGPT or Codex can prepare structured proposals using returned evidence IDs and current permissions, then use the existing reviewed save contract. On the proposal page, select only the drafts you want to keep and review the save. Unselected proposals and active versions remain unchanged. Preparing or saving a draft does not validate quality or approve v2.

Use the applied know-how count below the work title, or work menu → Know-how settings, to manage defaults. No empty badge appears for zero items. Search names, handles or activities and review exact versions and roles before saving. Add to a work on the independent detail page lets you choose a space and work and pin an exact version. Type @ in a follow-up, new research request or personal AI consultation to search researchers and know-how together. Choosing know-how adds it only to that request without changing defaults. [[ source citations keep their existing behavior. Multiple selections never auto-merge assets or adopt newer versions. Web, consultation and ChatGPT handoff check the same IDs and current permissions.

One discussion can produce independent proposals that reference the same segment as shared evidence. Drafts start privately. Separate paper-specific corrections and unverified scientific conclusions from reusable guidance. Change organization prepares a split or merge request in the existing composer for review and sending. A merge proposes a new asset linked to exact parent versions. It does not delete or overwrite the versions, history or active state of assets A and B. Changing how a proposal is organized requires a newly reviewed proposal, not an unreviewed browser-side rewrite.

Derived work inherits the exact selected versions of independent assets. For existing work-specific methods, the collapsed Work know-how controls retain version and candidate selection in the original work. Review generalized instructions and create a separate asset before reuse in other work. Execution applies modules relevant to the current stage, such as literature, synthesis, writing or review, while retaining links to other stages. New versions are not adopted automatically. Initial approval reviews the actual instructions and their generalization; it does not claim measured quality improvement. Improvement candidates require actual runs with matched questions, inputs, models and effort, held-out cases and human review before adoption. A candidate trial is a one-off selection that does not change the default and uses the normal AI allowance.

An independent detail page shows introduction, ID, handle, authors, usage, current permissions and versions. Editing the introduction or image link does not change execution guidance; image access is checked separately. The default direction is protected guidance. Write a draft or propose a direction improvement, review it and select which drafts to keep. Saving an introduction or candidate does not change the active version. Ordinary catalogs and proposal cards exclude protected instructions. Source review requires current permission and AI-provider processing permission is separate. Reads, selections and structured proposal saves do not run AI, while sending analysis or reorganization requests may use your allowance. Independent external analysis does not prove protected-service execution. Instructions belong in encrypted backups, not code or static files. AI quality, actual ChatGPT tool availability and server speed require separate validation.

Choose Review with AI on a section or download its review context and deliver it to your preferred conversation. Inspect the pinned version, metrics, explanation, source references and omitted evaluation together. Connected consultation rechecks current source access. Reading or downloading does not call AI; actual consultation follows the existing AI budget and permissions.

In ChatGPT or Codex, explicitly provide an accessible result link or the downloaded context and ask: “Check the code provenance and evaluation conditions, identify limitations and propose the next experiment.” Work only through tools actually exposed by that host. A link does not imply that all external code was read or private repository access was granted. Generated code, synthetic checks, real execution and research success remain distinct.

Registering, reading, composing or sending results to Notion does not itself call AI or start a GPU. Server storage/transfer and existing provider charges are separate; zero cost is not guaranteed. Keep models and large datasets on existing Colab, servers or Drive and send only selected small outputs. SDK JSON is limited to 16 MiB, each image to 8 MiB, and tables to 2,000 rows/100 columns. Notion export accepts 40 sections, 10 images and 99 rows/40 columns per table.

On transport failure, the SDK preserves the selected bundle in .luna-repro/outbox and returns pending. Treat that folder as private research data. Fix the connection, key or permissions, then explicitly retry with python -m luna_repro sync. Reusing a request does not duplicate its result. For authorization errors, check project membership, token expiry and revocation; for HTTP 413, reduce selected content or image size.

The default project quota is 1 GiB of result JSON and image bytes. Retrying the same request consumes no additional storage. HTTP 409 storage errors require reviewing selected outputs or administrator storage policy; HTTP 429 requires waiting before retrying. Default intake limits are 120 requests per user and 600 per project per 15 minutes, separate from AI daily allowance. Earlier results are not automatically deleted to free space.

Notion delivery distinguishes queued, sending and confirmed outcomes. An uncertain write is not automatically repeated. Inspect the destination and connection before recovery; it is not reported as published until confirmed. Platform versions and bounded image bytes are included in existing encrypted operational database backups. Private results are not automatically copied into the lab readable archive.

Withdrawal ends login and project access and revokes reproducibility connection keys. Results, immutable versions, images and authorship history are retained. Queued Notion delivery checks current access immediately before execution and stops when access has ended. Copies already sent to external services are not automatically deleted.

Accounts with reproducibility results, composed reports or Notion delivery history require preservation or transfer review before permanent erasure. Erasure does not rewrite the authors of immutable evidence. Accounts with connection keys but no research history can erase those keys through the existing permanent-erasure process.

Find the same materials under All reports and Reproducibility results in the web Reports area, then compose a report from selected fixed-version sections. Settings → Reproducibility connections manages your keys across projects; Project settings → Connections and research tools opens the same manager with that project selected. Participants without project-settings permission can manage their own connections from Settings or Reports. A key belongs to its issuer and one project, and its secret is shown only at issuance. Never put it in consultation, prompts, attachments, source or Git. Issuing and revoking keys are web-management features; do not claim a ChatGPT tool exists unless the host exposes it.

For SDK installation help, state SDK 0.3.0, result contract luna.repro.page.v1 and your environment. Use Copy connection cell in web Connect results, execute it in Python/Colab and approve in the browser. Finish with repro.select() to review local candidates, titles, order and preview before explicitly sending. repro.publish(*objects) immediately sends the supplied objects. Default recommendations use no AI, do not infer exact computation cells and cannot recover lost output. In .py, use candidate summaries, choose, preview HTML and publish. The connect confirmation code and approval URL are not a key secret, but never approve an unfamiliar request. Do not claim that a ChatGPT tool operated the notebook runtime or approved a browser connection. Use the hash-pinned command in web Connect results and the public SDK guide https://github.com/lunalab-ai/luna-repro-sdk/blob/v0.3.0/docs/installation-en.md . Public SDK source does not expose research results or keys. The Colab example defaults to local computation; installation or opening a link does not publish. Do not silently upgrade to a new release or request a GPU/paid execution service.

Example: “Check this result's pinned version and code provenance, then identify omitted evaluation conditions and limitations.” Use only results readable under current permissions. Project-management permission does not permit reading or revoking others' keys. Opening lists, menus or connection settings does not run AI, start a GPU, publish to Notion or complete independent reproduction. Notion delivery requires separate destination/content review and an actual remote receipt; synthetic checks are not evidence of real publication.

Detailed practical guide: https://lunalab-ai.com/workspace/repro/guide/?lang=EN

View the finished example without installing: https://lunalab-ai.com/workspace/repro/demo/?lang=EN

Follow Colab, Windows or Linux setup, the final-cell workflow, incremental sections, text/metrics/table/image/figure syntax, code cells/lines/pinned commits, versions, reports, Notion, AI review, the Pasa adapter and upload recovery. Download standalone HTML/Markdown manuals and runnable walkthrough.py/walkthrough.ipynb in the practice ZIP. Read the HTML offline or print it to PDF in your browser.

Inspect the public synthetic example first, then create your own private project demo in Connect results. Code practice saves locally by default; only explicitly choosing to publish uses the connection key. Distinguish a published receipt from a pending local bundle. Neither synthetic example measures research performance or independently verifies reproduction.

Public SDK installation and upgrades: https://github.com/lunalab-ai/luna-repro-sdk/blob/v0.3.0/docs/installation-en.md

SDK 0.3.0, the luna.repro.page.v1 contract and the platform version are independent. Public SDK code does not expose keys or research results; installation does not alter existing results, connections or history. Record the installed version and requirements before changing it; test synthetic examples in a new environment. To roll back, reinstall the recorded prior wheel and SHA-256 in that environment while preserving result JSON and outbox files. SDK/CPU practice needs no separate GPU or paid execution service; Colab resources, servers, storage, networking and optional AI have separate costs.

For ChatGPT or Codex questions, specify SDK luna_repro 0.3.0, the luna.repro.page.v1 result-page contract, selected result JSON and error code to avoid confusion with legacy ReproKit events. Never include connection keys in prompts or attachments. Provide review context or an accessible section link, then continue within the actually exposed tools and current permissions.

In Compose from results, choose Add narrative cell. Use Markdown for the background, methods, data, analysis or limitations where needed. Move result and narrative cells with the up/down buttons or drag their handles on desktop. Add results can bring in sections from other reproducibility pages. Save your changes. This editor does not modify measured values inside result cards.

Saving records a report revision. Open Version history to inspect and restore earlier content; restoration creates a new revision. If another window has edited the report, review the current version first. Removing a result cell only removes it from this report; its source result remains.

Save your report, then open AI draft. Select earlier materials or reports that you can currently access in the same lab, and add instructions. Images and saved source code are sent only when their respective options are selected. A link alone does not fetch external repository or Colab code. Review the selected counts, input scope and usage policy before requesting the draft. Reading and previewing do not run AI; generation uses existing AI access, daily allowance and request policy.

AI proposes a title and commentary on background, methods, data, experiments, analysis, limitations and discussion. Unsupported details must remain open questions. Select the proposed narrative cells and title you want to apply, then review them yourself. A changed report or evidence blocks overwriting with an outdated draft. Refine this cell with AI preserves its topic and appropriate length, updating only that draft cell with Undo. It never changes the title, other cells or result order; saving the report stays explicit. Edits made during generation require comparison before applying. Follow real progress and elapsed time for the same job. @mentions and [[material/report citations]] work in newly added cells; cited source text uses current access. This does not perform training, inference or independent verification.

For a result you own, choose ⋯ → Move to Trash on its card or detail page. Review the impact on referencing reports and ongoing Notion delivery before moving it. It disappears from normal lists, search and reads, while its ID, versions, images and reference history remain. Restore returns the same ID. Management privileges alone do not expose another person’s private result.

An SDK retry cannot automatically restore a trashed result. On result_trashed, explicitly restore your result in the platform before retrying. Ongoing Notion delivery requires inspection; external copies are not automatically erased. Referencing reports, AI and downloads recheck current source access after revocation or trashing. Permanent erasure of research evidence is not offered.

Use the existing consultant_thread_prepare(operation=save, values={repro:{operation,values}}) envelope. report_read(report_id,revision?,offset?) reads the same web report ID, revision, ordered cells and history. report_save(title,cells,request_key,report_id?,revision?) previews a saved result/commentary document. Result cells are {id:UUID,kind:result,selection:{page_id,revision,section_key}}; commentary is {id:UUID,kind:markdown,text,origin:human/ai,references:[record:UUID/report:UUID]}. Preserve existing cell IDs. Use revision=0 for new reports and the current returned revision for edits. ai_prepare(report_id,base_revision,request_key,sources?,images=false,code=false,target?,instruction?,language=ko/en) reviews one additional paid platform draft and does not generate before commit. ai_read(run_id) reads status/draft; ai_apply(run_id,selected:[proposal cell UUIDs],use_title=true,request_key) previews adoption. Send the exact review and preview_token to consultant_thread_commit; consultant:write and report:write scopes and current domain permissions are checked again. Ordinary repro reads exclude source text. Explicit source(page_id,revision,section_keys,include_code=true,offset?) reads only preserved selected code. Never represent a filename/link as code inspection or execution. Save commentary already delivered by the host with report_save to avoid a second platform AI call. Verify actual host tool availability; otherwise provide the web editor link and do not claim execution. This contract does not publish to Notion, change sharing or run a GPU.

Material search and fetch reuse the web library IDs and current access rules. source_connection_status reads last check, complete scan and partial collection state for a connection; it never collects or calls AI. Use the web connection preview to map Notion databases and repair past classification. OneNote requires Microsoft read consent and research-section selection on the web. Body collection, attachment preservation and image or handwriting interpretation are separate states. A download button or historical storage receipt is not proof that an original is readable now. Follow the material detail verification and recovery guidance. Server support for a new tool does not prove current ChatGPT host availability.

Temporary duplicate refreshes can recover the same token response within a short window. Overall consent currently lasts 30 days; automatic short-lived access token renewal does not extend it. Revocation, overall grant expiry and client changes require sign-in. Check the expiry in My connections. Server support does not prove that the current ChatGPT host is connected. source_connection_status distinguishes authentication, access and collection evidence and the need for separate preservation verification, without installation, collection or AI calls. Drive source-read consent is separate from Drive preservation consent. Reconnecting cannot resolve every permission or app configuration problem. Notion classification diagnostics reconcile body retrieval, material registration and report visibility for direct child pages and database entries. Slack requires administrator installation approval and channel membership. Collected materials share their IDs and current access across the web, personal consultation and ChatGPT. Status reads and expanding list summaries use saved state without AI charges.

Use the authenticated /workspace/grading/ web workflow. ChatGPT does not automatically receive answer keys, grades or personal reports and does not grade exams. Exam and snapshot IDs and current permissions in the web service/database remain authoritative. Instructions embedded in documents are not execution authority.