[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6FHZTH08EB9W074WM8BYMXG":3,"skill-same:01M6FHZTH08EB9W074WM8BYMXG":47},{"skillNo":4,"name":5,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":20,"linkOnly":21,"markdownContent":22,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M6FHZTH08EB9W074WM8BYMXG","subsystem-summary-of-historywork",null,"ComeOnOliver\u002Fskillshub","ComeOnOliver","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43215937?v=4","01M6E5JNFECJAAVFE0W7SMWWD2","Haoran Shu","01M6E5JNNDQS7AJZDYFQ8TPZCK",66,"MIT","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fstellar\u002Fstellar-core\u002Fsubsystem-summary-of-historywork\u002FSKILL.md",[],[18,19],"summary","subsystem summary of historywork","2026-11-10 10:12:30",false,"# Historywork Subsystem Technical Summary\n\nThe `historywork` subsystem implements the concrete work units (tasks) for stellar-core's history archive interactions. It provides the building blocks for publishing ledger history to archives and downloading\u002Fverifying history during catchup. All classes inherit from the `Work`\u002F`BasicWork`\u002F`BatchWork` framework defined in `src\u002Fwork\u002F`.\n\n---\n\n## Base Infrastructure\n\n### `RunCommandWork` (RunCommandWork.h\u002Fcpp)\n**Inherits:** `BasicWork`\n\nBase class for all work units that execute external shell commands via `ProcessManager`. Subclasses override `getCommand()` to return a `CommandInfo` (command string + optional output file path). The work spawns a process, enters `WORK_WAITING`, and wakes up via an async callback on `ProcessExitEvent` when the process completes.\n\n**Key functions:**\n- `onRun()`: If not done, calls `getCommand()`, spawns a process via `mApp.getProcessManager().runProcess()`, and installs an async callback that sets `mDone`\u002F`mEc` and calls `wakeUp()`.\n- `onReset()`: Clears done state, error code, and exit event.\n- `onAbort()`: Attempts `tryProcessShutdown()` on the running process.\n- `getCommand()`: Pure virtual — returns `CommandInfo{command, outFile}`.\n\n**Key data:**\n- `mDone` (bool): Whether the process has exited.\n- `mEc` (asio::error_code): Exit status of the process.\n- `mExitEvent` (weak_ptr\u003CProcessExitEvent>): Handle to the running process.\n\n### `CommandInfo` (RunCommandWork.h)\nSimple struct holding `mCommand` (shell command string) and `mOutFile` (optional output file path for redirected output).\n\n### `Progress` (Progress.h\u002Fcpp)\nUtility function `fmtProgress(app, task, range, curr)` that formats a human-readable progress string like `\"downloading ledger files 5\u002F10 (50%)\"` based on checkpoint frequency and a `LedgerRange`.\n\n---\n\n## File Transfer Operations (Low-level)\n\n### `GetRemoteFileWork` (GetRemoteFileWork.h\u002Fcpp)\n**Inherits:** `RunCommandWork`\n\nDownloads a single file from a history archive. If no specific archive is provided (`mArchive == nullptr`), selects a random readable archive on each run\u002Fretry via `HistoryArchiveManager::selectRandomReadableHistoryArchive()`.\n\n**Key functions:**\n- `getCommand()`: Resolves the archive (random or specified), calls `mCurrentArchive->getFileCmd(remote, local)` to get the shell download command.\n- `onSuccess()`: Records bytes downloaded to metrics.\n- `onFailureRaise()`: Records failure metric and logs a warning identifying the archive.\n\n**Key data:**\n- `mRemote`, `mLocal`: Source and destination paths.\n- `mArchive`: Fixed archive (or null for random selection).\n- `mCurrentArchive`: The archive actually used for the current attempt.\n- `mFailuresPerSecond`, `mBytesPerSecond`: Medida metrics.\n\n### `PutRemoteFileWork` (PutRemoteFileWork.h\u002Fcpp)\n**Inherits:** `RunCommandWork`\n\nUploads a single file to a history archive using `mArchive->putFileCmd(local, remote)`. Requires a non-null archive with put capability. Retries `RETRY_A_LOT`.\n\n### `MakeRemoteDirWork` (MakeRemoteDirWork.h\u002Fcpp)\n**Inherits:** `RunCommandWork`\n\nCreates a directory on a remote archive via `mArchive->mkdirCmd(dir)`. If the archive has no mkdir command, the command string is empty and the work succeeds immediately. Retries `RETRY_A_LOT`.\n\n### `GzipFileWork` (GzipFileWork.h\u002Fcpp)\n**Inherits:** `RunCommandWork`\n\nCompresses a local file using `gzip`. Supports a `keepExisting` mode that uses `gzip -c` and redirects to an output file. On reset, removes the `.gz` file.\n\n### `GunzipFileWork` (GunzipFileWork.h\u002Fcpp)\n**Inherits:** `RunCommandWork`\n\nDecompresses a `.gz` file using `gzip -d`. Supports `keepExisting` mode. Defaults to `RETRY_NEVER`. On reset, removes the decompressed file.\n\n---\n\n## Composite Download Operations\n\n### `GetAndUnzipRemoteFileWork` (GetAndUnzipRemoteFileWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nTwo-phase work: downloads a gzipped file from a history archive then gunzips it locally. Orchestrates `GetRemoteFileWork` → file validation (rename `.gz.tmp` to `.gz`) → `GunzipFileWork`.\n\n**Key functions:**\n- `doWork()`: Three-state machine: (1) spawn `GetRemoteFileWork`, (2) on download success, validate file and spawn `GunzipFileWork`, (3) check gunzip result and verify `.nogz` file exists.\n- `validateFile()`: Renames `.gz.tmp` → `.gz`, checking existence at each step.\n- `doReset()`: Removes all local file variants (`.nogz`, `.gz`, `.gz.tmp`).\n- `onSuccess()`: Notifies `LedgerApplyManager::fileDownloaded()`.\n- `onFailureRaise()`: Logs potential archive corruption.\n- `getArchive()`: Returns the archive used if download succeeded.\n\n**Key data:**\n- `mFt` (FileTransferInfo): Describes the file being transferred (type, paths, checkpoint).\n- `mArchive`: Optional fixed archive.\n- `mGetRemoteFileWork`, `mGunzipFileWork`: Child work references.\n\n### `BatchDownloadWork` (BatchDownloadWork.h\u002Fcpp)\n**Inherits:** `BatchWork`\n\nDownloads a range of checkpoint files of a given `FileType` (ledger headers, transactions, results, SCP messages). Iterates over a `CheckpointRange`, yielding one `GetAndUnzipRemoteFileWork` per checkpoint. `BatchWork` manages parallelism.\n\n**Key functions:**\n- `yieldMoreWork()`: Creates a `GetAndUnzipRemoteFileWork` for the next checkpoint in range, advances `mNext`.\n- `hasNext()`: Returns true if `mNext \u003C mRange.limit()`.\n- `resetIter()`: Resets `mNext` to `mRange.mFirst`.\n\n**Key data:**\n- `mRange` (CheckpointRange): The range of checkpoints to download.\n- `mNext` (uint32_t): Next checkpoint to yield.\n- `mFileType` (FileType): Type of history files to download.\n- `mDownloadDir` (TmpDir ref): Local temp directory for downloads.\n\n---\n\n## Bucket Download & Verification\n\n### `DownloadBucketsWork` (DownloadBucketsWork.h\u002Fcpp)\n**Inherits:** `BatchWork`\n\nDownloads, verifies, and adopts all bucket files needed for catchup. Handles both `LiveBucket` and `HotArchiveBucket` types via a templated inner `BucketState\u003CBucketT>` struct. Each bucket goes through a three-step sequence: download → verify+index → adopt.\n\n**Key functions:**\n- `yieldMoreWork()`: For each bucket hash, creates a `WorkSequence` of: `GetAndUnzipRemoteFileWork` → `VerifyBucketWork\u003CBucketT>` → `WorkWithCallback` (adopt). Iterates live buckets first, then hot archive buckets.\n- `prepareWorkForBucketType\u003CBucketT>()`: Template helper that creates the verify work and the adopt callback, managing index storage and mutex locking.\n- `onSuccessCb\u003CBucketT>()`: Static callback that extracts the verified index, calls `BucketManager::adoptFileAsBucket`, and stores the result in the output map.\n\n**Key data:**\n- `BucketState\u003CBucketT>`: Inner template struct containing:\n  - `buckets`: Reference to output map of hash→Bucket.\n  - `hashes`: Vector of bucket hashes to download.\n  - `nextIter`: Iterator tracking progress.\n  - `indexMap`: Map of ID→index pointer, used for ownership transfer between verify and adopt steps.\n  - `mutex`: Protects concurrent access to `buckets` and `indexMap`.\n  - `indexId`: Monotonic counter for indexMap keys.\n- `mLiveBucketsState`, `mHotBucketsState`: Separate state for each bucket type.\n\n### `VerifyBucketWork\u003CBucketT>` (VerifyBucketWork.h\u002Fcpp)\n**Inherits:** `BasicWork` (template class)\n\nVerifies a bucket file's SHA-256 hash and builds its index, running on a background thread. Template instantiated for `LiveBucket` and `HotArchiveBucket`.\n\n**Key functions:**\n- `onRun()`: If not done, calls `spawnVerifier()` and returns `WORK_WAITING`.\n- `spawnVerifier()`: Checks bucket size against `MAX_HISTORY_ARCHIVE_BUCKET_SIZE`, then posts work to background thread. Background thread calls `createIndex\u003CBucketT>()` (which also computes the hash via a `SHA256` hasher), then posts result back to main thread setting `mIndex`, `mEc`, `mDone`.\n- `onFailureRaise()`: Calls `mOnFailure` callback if set.\n\n**Key data:**\n- `mBucketFile` (string): Path to the bucket file.\n- `mHash` (uint256): Expected hash.\n- `mIndex` (shared_ptr ref): Output index pointer, written by the background verifier.\n- `mOnFailure` (OnFailureCallback): Called on verification failure for logging.\n- `mDone` (bool), `mEc` (error_code): Completion status.\n\n---\n\n## Transaction Result Verification\n\n### `VerifyTxResultsWork` (VerifyTxResultsWork.h\u002Fcpp)\n**Inherits:** `BasicWork`\n\nVerifies transaction results for a single checkpoint by comparing `txSetResultHash` in ledger headers against computed SHA-256 hashes of transaction result sets. Runs verification on a background thread.\n\n**Key functions:**\n- `onRun()`: Posts `verifyTxResultsOfCheckpoint()` to background thread. On completion, posts result back to main thread.\n- `verifyTxResultsOfCheckpoint()`: Opens ledger header and result XDR files, iterates through all headers in the checkpoint, loads corresponding result sets, and verifies each hash matches.\n- `getCurrentTxResultSet()`: Reads from the result XDR stream, validates ledger is within checkpoint range and monotonically increasing.\n\n**Key data:**\n- `mDownloadDir` (TmpDir ref): Directory containing downloaded files.\n- `mCheckpoint` (uint32_t): The checkpoint being verified.\n- `mHdrIn`, `mResIn` (XDRInputFileStream): Streams for header and result files.\n- `mLastSeenLedger` (uint32_t): Tracks monotonic ordering of result entries.\n\n### `DownloadVerifyTxResultsWork` (DownloadVerifyTxResultsWork.h\u002Fcpp)\n**Inherits:** `BatchWork`\n\nBatch work that downloads and verifies transaction results for a range of checkpoints. Each checkpoint yields a `WorkSequence` of `GetAndUnzipRemoteFileWork` (results) → `VerifyTxResultsWork`.\n\n---\n\n## History Archive State\n\n### `GetHistoryArchiveStateWork` (GetHistoryArchiveStateWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nDownloads and parses a `HistoryArchiveState` (HAS) JSON file from an archive. The HAS describes the current state of an archive including its latest ledger and bucket list references.\n\n**Key functions:**\n- `doWork()`: Spawns `GetRemoteFileWork` to download the HAS file; on success, calls `mState.load(mLocalFilename)` to parse the JSON.\n- `getHistoryArchiveState()`: Accessor (only valid after `WORK_SUCCESS`).\n- `getRemoteName()`: Returns either the well-known path (seq==0) or a ledger-specific path.\n- `onSuccess()`: Optionally reports metrics via `LedgerApplyMananger::historyArchiveStatesDownloaded()`.\n\n**Key data:**\n- `mState` (HistoryArchiveState): Parsed result.\n- `mSeq` (uint32_t): Target ledger sequence (0 = latest\u002Fwell-known).\n- `mArchive`: Archive to fetch from (null = random).\n- `mLocalFilename` (string): Temp local file path (random hex name).\n\n### `PutHistoryArchiveStateWork` (PutHistoryArchiveStateWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nSerializes and uploads a `HistoryArchiveState` to an archive. Validates that the HAS contains valid buckets before publishing. Uploads to both the ledger-specific path and the well-known path (`\u002F.well-known\u002Fstellar-history.json`).\n\n**Key functions:**\n- `doWork()`: Saves HAS to local file, then calls `spawnPublishWork()`.\n- `spawnPublishWork()`: Creates two parallel `WorkSequence`s: one for the seq-specific path and one for the well-known path. Each sequence is `MakeRemoteDirWork` → `PutRemoteFileWork`.\n\n---\n\n## Publishing Pipeline\n\n### `ResolveSnapshotWork` (ResolveSnapshotWork.h\u002Fcpp)\n**Inherits:** `BasicWork`\n\nWaits for a `StateSnapshot`'s bucket futures to resolve. Delays one ledger past the snapshot ledger (unless standalone) to guard against publishing divergent data.\n\n**Key functions:**\n- `onRun()`: Calls `prepareForPublish()` and `resolveAnyReadyFutures()` on the snapshot. If all futures are resolved and we're past the conservative delay, returns `WORK_SUCCESS`. Otherwise sets up a 1-second polling wait.\n\n### `WriteSnapshotWork` (WriteSnapshotWork.h\u002Fcpp)\n**Inherits:** `BasicWork`\n\nWrites SCP messages from a `StateSnapshot` to local files. Runs on a background thread if DB connection pooling is available, otherwise on the main thread via `postOnMainThread`.\n\n**Key functions:**\n- `onRun()`: Posts a lambda that calls `mSnapshot->writeSCPMessages()`. On completion, posts back to main thread setting `mDone` and `mSuccess`.\n\n### `PutSnapshotFilesWork` (PutSnapshotFilesWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nThree-phase orchestrator for uploading a snapshot to all writable archives:\n1. **Get archive states:** Spawns `GetHistoryArchiveStateWork` for each writable archive to learn what files they already have.\n2. **Gzip files:** Compresses only the files that differ between the snapshot and each archive's current state (avoids redundant uploads). Uses `StateSnapshot::differingHASFiles()`.\n3. **Upload:** For each archive, spawns a `WorkSequence` of `PutFilesWork` → `PutHistoryArchiveStateWork`.\n\n**Key data:**\n- `mGetStateWorks`: List of archive state download works.\n- `mGzipFilesWorks`: List of gzip works for differing files.\n- `mUploadSeqs`: List of upload work sequences.\n- `mFilesToUpload`: Map of local path → `FileTransferInfo` (deduplicates across archives).\n\n### `PutFilesWork` (PutFilesWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nUploads all differing files for a single archive. For each file from `mSnapshot->differingHASFiles(remoteState)`, creates a `WorkSequence` of `MakeRemoteDirWork` → `PutRemoteFileWork`.\n\n### `PublishWork` (PublishWork.h\u002Fcpp)\n**Inherits:** `WorkSequence`\n\nTop-level publish work that wraps a sequence of publish steps. On success or failure, notifies `HistoryManager::historyPublished()` with the ledger number and bucket hashes. Stores `mOriginalBuckets` separately because the snapshot's bucket list may change during async execution.\n\n---\n\n## Verification & Integrity Checking\n\n### `CheckSingleLedgerHeaderWork` (CheckSingleLedgerHeaderWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nOffline self-check: downloads the checkpoint file containing a given `LedgerHeaderHistoryEntry`, scans it, and verifies the archive copy matches the expected local copy. Used by the offline self-check command.\n\n**Key functions:**\n- `doWork()`: Downloads checkpoint via `GetAndUnzipRemoteFileWork`, then synchronously scans the XDR file comparing each header against `mExpected`.\n\n**Key data:**\n- `mExpected` (LedgerHeaderHistoryEntry): The expected header to verify.\n- `mArchive`: The archive to check against.\n- `mCheckSuccess`, `mCheckFailed`: Medida metrics.\n\n### `WriteVerifiedCheckpointHashesWork` (WriteVerifiedCheckpointHashesWork.h\u002Fcpp)\n**Inherits:** `BatchWork`\n\nProduces a JSON file of verified `[ledger_seq, hash]` pairs by downloading ledger header files and running `VerifyLedgerChainWork` on them in a chained fashion. Works backwards from a trusted `mRangeEnd` toward genesis (or a `fromLedger`\u002F`latestTrustedHashPair` if specified).\n\n**Key functions:**\n- `yieldMoreWork()`: For each batch, creates a `WorkSequence` of `BatchDownloadWork` (ledger headers) → `ConditionalWork` wrapping `VerifyLedgerChainWork`. Each `VerifyLedgerChainWork` depends on the previous one's verified hash output via a `shared_future\u003CLedgerNumHashPair>`.\n- `startOutputFile()` \u002F `endOutputFile()`: Manage the JSON output file lifecycle. If a `trustedHashFile` is provided, its content is appended to the output.\n- `loadHashFromJsonOutput()` \u002F `loadLatestHashPairFromJsonOutput()`: Static helpers to read back hashes from the JSON output.\n\n**Key data:**\n- `mRangeEnd` (LedgerNumHashPair): The trusted endpoint (highest ledger).\n- `mRangeEndPromise` \u002F `mRangeEndFuture`: Promise\u002Ffuture pair providing the trusted hash to the first link in the verification chain.\n- `mCurrCheckpoint` (uint32_t): Current iteration point, decreasing toward genesis.\n- `mPrevVerifyWork`: Previous `VerifyLedgerChainWork`, whose output future feeds the next batch.\n- `mNestedBatchSize`: Controls inner parallelism (default 64 checkpoints per batch).\n- `mTmpDirs`: Vector of (WorkSequence, TmpDir) pairs; TmpDirs are cleaned up as sequences complete.\n- `mOutputFile`: Shared output stream written by `VerifyLedgerChainWork` instances.\n- `mTrustedHashPath`, `mLatestTrustedHashPair`, `mFromLedger`: Optional parameters for incremental verification.\n\n---\n\n## SCP \u002F Quorum Set Fetching\n\n### `FetchRecentQsetsWork` (FetchRecentQsetsWork.h\u002Fcpp)\n**Inherits:** `Work`\n\nThree-phase work for downloading and scanning recent SCP messages to discover active quorum sets:\n1. Fetches the latest archive state via `GetHistoryArchiveStateWork`.\n2. Downloads SCP message files for the last ~100 checkpoints (~9 hours) via `BatchDownloadWork`.\n3. Scans downloaded XDR files to extract `SCPHistoryEntry` records.\n\n---\n\n## Key Data Flows\n\n### Publish Flow\n```\nResolveSnapshotWork (wait for bucket futures)\n  → WriteSnapshotWork (write SCP messages to local files)\n    → PutSnapshotFilesWork\n      → GetHistoryArchiveStateWork (per archive, get current state)\n      → GzipFileWork (gzip only differing files)\n      → PutFilesWork (per archive: MakeRemoteDirWork → PutRemoteFileWork per file)\n      → PutHistoryArchiveStateWork (upload HAS JSON to seq path + well-known path)\n```\nAll wrapped in `PublishWork` (a `WorkSequence`) which notifies `HistoryManager` on completion.\n\n### Download\u002FCatchup Flow\n```\nBatchDownloadWork (download checkpoint files of a given type: ledgers, txs, results, SCP)\n  → GetAndUnzipRemoteFileWork (per checkpoint)\n    → GetRemoteFileWork (download .gz)\n    → GunzipFileWork (decompress)\n\nDownloadBucketsWork (download+verify+adopt all buckets)\n  → per bucket: GetAndUnzipRemoteFileWork → VerifyBucketWork → adopt callback\n\nDownloadVerifyTxResultsWork (download+verify tx results)\n  → per checkpoint: GetAndUnzipRemoteFileWork → VerifyTxResultsWork\n```\n\n### Verified Checkpoint Hash Chain\n```\nWriteVerifiedCheckpointHashesWork (iterates backwards from trusted endpoint)\n  → per batch: BatchDownloadWork (ledger headers)\n    → ConditionalWork(predicate: prev batch succeeded)\n      → VerifyLedgerChainWork (verifies hash chain, writes to shared output file)\n         (chained via shared_future\u003CLedgerNumHashPair> from previous batch)\n```\n\n---\n\n## Threading Model\n\n- **Main thread**: All `Work` state machine transitions, scheduling, and `doWork()`\u002F`onRun()` calls.\n- **Background threads** (via `postOnBackgroundThread`):\n  - `VerifyBucketWork::spawnVerifier()`: SHA-256 hashing and index creation.\n  - `VerifyTxResultsWork::onRun()`: Transaction result verification.\n  - `WriteSnapshotWork::onRun()`: SCP message writing (if DB pooling available).\n- **External processes** (via `ProcessManager::runProcess`): All `RunCommandWork` subclasses (gzip, gunzip, get\u002Fput remote files, mkdir). These spawn shell commands and use async `ProcessExitEvent` callbacks.\n- **Synchronization**: `DownloadBucketsWork::BucketState` uses `std::mutex` to protect `buckets` and `indexMap` maps accessed from both main and background threads. Background workers always post results back to main thread via `postOnMainThread` before modifying `BasicWork` state.\n\n---\n\n## Ownership & Lifetime\n\n- `Work` objects form a tree: parent works own child works via `addWork\u003CT>()`. The work scheduler drives the tree.\n- `StateSnapshot` is shared across the publish pipeline via `shared_ptr`.\n- `TmpDir` objects own temporary directories; their destructors clean up files. `WriteVerifiedCheckpointHashesWork` explicitly manages TmpDir lifetime per batch.\n- `HistoryArchive` is shared via `shared_ptr` and may be null (meaning \"pick randomly\").\n- `FileTransferInfo` is a value type describing file paths and types; not heap-allocated.\n- `BatchWork` (parent class) manages the pool of active child works and controls parallelism.\n",{},"main","def8531e65114c0fca8fb8551c1871ee0eed705c","skills\u002Fstellar\u002Fstellar-core\u002Fsubsystem-summary-of-historywork",24,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub","https:\u002F\u002Fskillshub.wtf","https:\u002F\u002Fgithub.com\u002FComeOnOliver","AI & Blockchain Engineer\r\n","2026-06-24 22:07:19",{"source":7,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add ComeOnOliver\u002Fskillshub --skill subsystem-summary-of-historywork",{"tool":39,"command":40},"bunx","bunx skills add ComeOnOliver\u002Fskillshub --skill subsystem-summary-of-historywork",{"tool":42,"command":43},"pnpm","pnpm dlx skills add ComeOnOliver\u002Fskillshub --skill subsystem-summary-of-historywork","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fstellar\u002Fstellar-core\u002Fsubsystem-summary-of-historywork\u002FSKILL.md",true,[],[48,62,72,81,87,94],{"skillNo":49,"name":50,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":51,"categories":52,"keywords":58,"publishedAt":20},"01M6FKJN13GMG4KY57J3QD8GY5","model-hierarchy-skill","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzscole\u002Fmodel-hierarchy-skill\u002Fmodel-hierarchy-skill\u002FSKILL.md",[53],{"categoryNo":54,"categoryName":55,"taxonomyType":56,"taxonomyTypeDesc":57},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[59,60,61],"model","model hierarchy","model hierarchy skill",{"skillNo":63,"name":64,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":68,"publishedAt":20},"01M6FKJJJ6GCAMR4PPPRD12M5X","zoom-mcp","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-mcp\u002FSKILL.md",[67],{"categoryNo":54,"categoryName":55,"taxonomyType":56,"taxonomyTypeDesc":57},[69,70,71],"MCP","zoom","zoom mcp",{"skillNo":73,"name":74,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":20},"01M6FKJE3KYT3KPEZMEEHYKA6K","zoom-apps-sdk","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-apps-sdk\u002FSKILL.md",[],[78,79,80,70],"sdk","zoom apps sdk","apps",{"skillNo":82,"name":83,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":84,"categories":85,"keywords":86,"publishedAt":20},"01M6FKJ9EDH9Q5VWDF8HAJRSP0","windows","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwindows\u002FSKILL.md",[],[83],{"skillNo":88,"name":89,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":93,"publishedAt":20},"01M6FKJ666BEEFC3AE9GJ72Q93","whiteboard","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwhiteboard\u002FSKILL.md",[92],{"categoryNo":54,"categoryName":55,"taxonomyType":56,"taxonomyTypeDesc":57},[89],{"skillNo":95,"name":96,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":97,"categories":98,"keywords":99,"publishedAt":20},"01M6FKJ21WFCDGTJQ2Q91T9DVW","websockets","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwebsockets\u002FSKILL.md",[],[96]]